diff --git "a/parse/train/HkepKG-Rb/HkepKG-Rb_middle.json" "b/parse/train/HkepKG-Rb/HkepKG-Rb_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/HkepKG-Rb/HkepKG-Rb_middle.json" @@ -0,0 +1,40979 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 462, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 366, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 366, + 98 + ], + "score": 1.0, + "content": "A SEMANTIC LOSS FUNCTION FOR", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 97, + 463, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 97, + 463, + 117 + ], + "score": 1.0, + "content": "DEEP LEARNING WITH SYMBOLIC KNOWLEDGE", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 278, + 175, + 333, + 187 + ], + "lines": [ + { + "bbox": [ + 276, + 175, + 335, + 189 + ], + "spans": [ + { + "bbox": [ + 276, + 175, + 335, + 189 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 143, + 204, + 468, + 315 + ], + "lines": [ + { + "bbox": [ + 141, + 204, + 469, + 218 + ], + "spans": [ + { + "bbox": [ + 141, + 204, + 469, + 218 + ], + "score": 1.0, + "content": "This paper develops a novel methodology for using symbolic knowledge in deep", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 141, + 215, + 469, + 228 + ], + "spans": [ + { + "bbox": [ + 141, + 215, + 469, + 228 + ], + "score": 1.0, + "content": "learning. From first principles, we derive a semantic loss function that bridges", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 226, + 469, + 239 + ], + "spans": [ + { + "bbox": [ + 141, + 226, + 469, + 239 + ], + "score": 1.0, + "content": "between neural output vectors and logical constraints. This loss function captures", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 238, + 469, + 250 + ], + "spans": [ + { + "bbox": [ + 141, + 238, + 469, + 250 + ], + "score": 1.0, + "content": "how close the neural network is to satisfying the constraints on its output. An", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 249, + 469, + 261 + ], + "spans": [ + { + "bbox": [ + 141, + 249, + 469, + 261 + ], + "score": 1.0, + "content": "experimental evaluation shows that our semantic loss function effectively guides", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 259, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 141, + 259, + 470, + 271 + ], + "score": 1.0, + "content": "the learner to achieve (near-)state-of-the-art results on semi-supervised multi-class", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 270, + 470, + 283 + ], + "spans": [ + { + "bbox": [ + 141, + 270, + 470, + 283 + ], + "score": 1.0, + "content": "classification. Moreover, it significantly increases the ability of the neural network", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 282, + 469, + 294 + ], + "spans": [ + { + "bbox": [ + 142, + 282, + 469, + 294 + ], + "score": 1.0, + "content": "to predict structured objects, such as rankings and paths. These discrete concepts", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 292, + 469, + 306 + ], + "spans": [ + { + "bbox": [ + 141, + 292, + 469, + 306 + ], + "score": 1.0, + "content": "are tremendously difficult to learn, and benefit from a tight integration of deep", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 304, + 314, + 316 + ], + "spans": [ + { + "bbox": [ + 141, + 304, + 314, + 316 + ], + "score": 1.0, + "content": "learning and symbolic reasoning methods.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 108, + 345, + 206, + 358 + ], + "lines": [ + { + "bbox": [ + 105, + 344, + 208, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 208, + 361 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 373, + 505, + 484 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "The widespread success of representation learning raises the question of which AI tasks are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "amenable to deep learning, which require classical model-based symbolic reasoning, and whether", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "score": 1.0, + "content": "we can benefit from an integration of both. In recent years, significant effort has gone towards var-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "ious ways of using representation learning to solve tasks that were previously tackled by symbolic", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 416, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 431 + ], + "score": 1.0, + "content": "methods. Such efforts include neural computers, Turing machines, and differentiable programming", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "(e.g., Weston et al. (2014); Reed & De Freitas (2015); Graves et al. (2016); Riedel et al. (2016)),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "relational embeddings, deep learning for graph data, and neural theorem proving (e.g., Bordes et al.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "(2013); Neelakantan et al. (2015); Duvenaud et al. (2015); Niepert et al. (2016)), and many more.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Other work has sought to augment deep learning with (symbolic) knowledge (e.g., Hu et al. (2016);", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 471, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 485 + ], + "score": 1.0, + "content": "Stewart & Ermon (2017); Marquez-Neila et al. (2017); Minervini et al. (2017); Wang et al. (2017)). ´", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 501 + ], + "score": 1.0, + "content": "This paper considers learning tasks where we have symbolic knowledge connecting the different", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "outputs of a neural network. This knowledge takes the form of a constraint (or sentence) in Boolean", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "logic. It can be as simple as an exactly-one constraint for one-hot output encodings, or as complex", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 521, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 536 + ], + "score": 1.0, + "content": "as a structured output prediction constraint for intricate combinatorial objects such as rankings,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "subgraphs, and paths. Our goal is to augment neural networks with the ability to learn how to make", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "predictions subject to these constraints, and use the symbolic knowledge to improve its performance.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "Most neuro-symbolic approaches aim to simulate or learn symbolic reasoning in an end-to-end deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "score": 1.0, + "content": "neural network, or capture symbolic knowledge in a vector-space embedding. This choice is partly", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "motivated by the need for smooth differentiable models; adding symbolic reasoning code (e.g., SAT", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 592, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 608 + ], + "score": 1.0, + "content": "solvers) to a deep learning pipeline destroys this property. Unfortunately, while making reasoning", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "differentiable, the precise logical meaning of the knowledge is often lost. In this paper, we take a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 614, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 630 + ], + "score": 1.0, + "content": "distinctly different approach, and tackle the problem of differentiable but sound logical reasoning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "from first principles. Starting from a set of intuitive axioms, we derive a differentiable semantic", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "loss function that captures how well the outputs of a neural network match a given constraint. This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 648, + 468, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 468, + 662 + ], + "score": 1.0, + "content": "function precisely captures the meaning of the constraint, and is independent of its syntax.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Next, we show how this semantic loss gives significant practical improvements in semi-supervised", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "classification. The semantic loss defined over the exactly-one constraint in this setting permits us to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "obtain a learning signal from vast amounts of unlabeled data. The key idea is that the semantic loss", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "helps us improve how consistently we are able to classify the unlabeled data. This simple addition to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "the loss function of standard deep learning architectures yields (near-)state-of-the-art performance", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 721, + 429, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 429, + 732 + ], + "score": 1.0, + "content": "in semi-supervised classification on MNIST, FASHION and CIFAR-10 datasets.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 303, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 462, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 77, + 366, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 77, + 366, + 98 + ], + "score": 1.0, + "content": "A SEMANTIC LOSS FUNCTION FOR", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 97, + 463, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 97, + 463, + 117 + ], + "score": 1.0, + "content": "DEEP LEARNING WITH SYMBOLIC KNOWLEDGE", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 278, + 175, + 333, + 187 + ], + "lines": [ + { + "bbox": [ + 276, + 175, + 335, + 189 + ], + "spans": [ + { + "bbox": [ + 276, + 175, + 335, + 189 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 143, + 204, + 468, + 315 + ], + "lines": [ + { + "bbox": [ + 141, + 204, + 469, + 218 + ], + "spans": [ + { + "bbox": [ + 141, + 204, + 469, + 218 + ], + "score": 1.0, + "content": "This paper develops a novel methodology for using symbolic knowledge in deep", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 141, + 215, + 469, + 228 + ], + "spans": [ + { + "bbox": [ + 141, + 215, + 469, + 228 + ], + "score": 1.0, + "content": "learning. From first principles, we derive a semantic loss function that bridges", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 226, + 469, + 239 + ], + "spans": [ + { + "bbox": [ + 141, + 226, + 469, + 239 + ], + "score": 1.0, + "content": "between neural output vectors and logical constraints. This loss function captures", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 238, + 469, + 250 + ], + "spans": [ + { + "bbox": [ + 141, + 238, + 469, + 250 + ], + "score": 1.0, + "content": "how close the neural network is to satisfying the constraints on its output. An", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 249, + 469, + 261 + ], + "spans": [ + { + "bbox": [ + 141, + 249, + 469, + 261 + ], + "score": 1.0, + "content": "experimental evaluation shows that our semantic loss function effectively guides", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 259, + 470, + 271 + ], + "spans": [ + { + "bbox": [ + 141, + 259, + 470, + 271 + ], + "score": 1.0, + "content": "the learner to achieve (near-)state-of-the-art results on semi-supervised multi-class", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 270, + 470, + 283 + ], + "spans": [ + { + "bbox": [ + 141, + 270, + 470, + 283 + ], + "score": 1.0, + "content": "classification. Moreover, it significantly increases the ability of the neural network", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 282, + 469, + 294 + ], + "spans": [ + { + "bbox": [ + 142, + 282, + 469, + 294 + ], + "score": 1.0, + "content": "to predict structured objects, such as rankings and paths. These discrete concepts", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 292, + 469, + 306 + ], + "spans": [ + { + "bbox": [ + 141, + 292, + 469, + 306 + ], + "score": 1.0, + "content": "are tremendously difficult to learn, and benefit from a tight integration of deep", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 304, + 314, + 316 + ], + "spans": [ + { + "bbox": [ + 141, + 304, + 314, + 316 + ], + "score": 1.0, + "content": "learning and symbolic reasoning methods.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 7.5, + "bbox_fs": [ + 141, + 204, + 470, + 316 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 345, + 206, + 358 + ], + "lines": [ + { + "bbox": [ + 105, + 344, + 208, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 208, + 361 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 373, + 505, + 484 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "The widespread success of representation learning raises the question of which AI tasks are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "amenable to deep learning, which require classical model-based symbolic reasoning, and whether", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "score": 1.0, + "content": "we can benefit from an integration of both. In recent years, significant effort has gone towards var-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "ious ways of using representation learning to solve tasks that were previously tackled by symbolic", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 416, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 431 + ], + "score": 1.0, + "content": "methods. Such efforts include neural computers, Turing machines, and differentiable programming", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "(e.g., Weston et al. (2014); Reed & De Freitas (2015); Graves et al. (2016); Riedel et al. (2016)),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "relational embeddings, deep learning for graph data, and neural theorem proving (e.g., Bordes et al.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 506, + 463 + ], + "score": 1.0, + "content": "(2013); Neelakantan et al. (2015); Duvenaud et al. (2015); Niepert et al. (2016)), and many more.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Other work has sought to augment deep learning with (symbolic) knowledge (e.g., Hu et al. (2016);", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 471, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 485 + ], + "score": 1.0, + "content": "Stewart & Ermon (2017); Marquez-Neila et al. (2017); Minervini et al. (2017); Wang et al. (2017)). ´", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 374, + 506, + 485 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 501 + ], + "score": 1.0, + "content": "This paper considers learning tasks where we have symbolic knowledge connecting the different", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "outputs of a neural network. This knowledge takes the form of a constraint (or sentence) in Boolean", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "logic. It can be as simple as an exactly-one constraint for one-hot output encodings, or as complex", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 521, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 536 + ], + "score": 1.0, + "content": "as a structured output prediction constraint for intricate combinatorial objects such as rankings,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "subgraphs, and paths. Our goal is to augment neural networks with the ability to learn how to make", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "predictions subject to these constraints, and use the symbolic knowledge to improve its performance.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 488, + 505, + 558 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "Most neuro-symbolic approaches aim to simulate or learn symbolic reasoning in an end-to-end deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "score": 1.0, + "content": "neural network, or capture symbolic knowledge in a vector-space embedding. This choice is partly", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "motivated by the need for smooth differentiable models; adding symbolic reasoning code (e.g., SAT", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 592, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 608 + ], + "score": 1.0, + "content": "solvers) to a deep learning pipeline destroys this property. Unfortunately, while making reasoning", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "differentiable, the precise logical meaning of the knowledge is often lost. In this paper, we take a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 614, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 630 + ], + "score": 1.0, + "content": "distinctly different approach, and tackle the problem of differentiable but sound logical reasoning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "from first principles. Starting from a set of intuitive axioms, we derive a differentiable semantic", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "loss function that captures how well the outputs of a neural network match a given constraint. This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 648, + 468, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 468, + 662 + ], + "score": 1.0, + "content": "function precisely captures the meaning of the constraint, and is independent of its syntax.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 561, + 506, + 662 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Next, we show how this semantic loss gives significant practical improvements in semi-supervised", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "classification. The semantic loss defined over the exactly-one constraint in this setting permits us to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "obtain a learning signal from vast amounts of unlabeled data. The key idea is that the semantic loss", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "helps us improve how consistently we are able to classify the unlabeled data. This simple addition to", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "the loss function of standard deep learning architectures yields (near-)state-of-the-art performance", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 721, + 429, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 429, + 732 + ], + "score": 1.0, + "content": "in semi-supervised classification on MNIST, FASHION and CIFAR-10 datasets.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 665, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 160, + 81, + 449, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 160, + 81, + 449, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 160, + 81, + 449, + 183 + ], + "spans": [ + { + "bbox": [ + 160, + 81, + 449, + 183 + ], + "score": 0.961, + "type": "image", + "image_path": "908b06431175243b10447e79ffaca6771156931dd43e1b26edd7a157a8c2ba04.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 160, + 81, + 449, + 115.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 160, + 115.0, + 449, + 149.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 160, + 149.0, + 449, + 183.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 193, + 505, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 207 + ], + "score": 1.0, + "content": "Figure 1: Outputs of a neural network feed into semantic loss functions for constraints representing", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 204, + 413, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 413, + 217 + ], + "score": 1.0, + "content": "a one-hot encoding, a total ranking of preferences, and paths in a grid graph.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 238, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 106, + 239, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 505, + 250 + ], + "score": 1.0, + "content": "Our final set of experiments study the benefits of the semantic loss function for complex structured", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 249, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 262 + ], + "score": 1.0, + "content": "output learning tasks, such as preference learning and path prediction in a graph (Daume et al., 2009; ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "score": 1.0, + "content": "Chang et al., 2013; Choi et al., 2015; Graves et al., 2016). In these scenarios, the task is two-fold:", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 270, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 284 + ], + "score": 1.0, + "content": "learn both the structure of the output space, and the actual classification function within that space.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "By capturing the structure of the output space with logical constraints, and minimizing the semantic", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "loss for this constraint during learning, we are able to learn networks that are much more likely to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 304, + 251, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 251, + 317 + ], + "score": 1.0, + "content": "correctly predict structured objects.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 108, + 333, + 282, + 345 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 284, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 284, + 348 + ], + "score": 1.0, + "content": "2 BACKGROUND AND NOTATION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 358, + 505, + 458 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 505, + 370 + ], + "score": 1.0, + "content": "To formally define semantic loss, we make use of concepts in propositional logic. We write upper-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 370, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 154, + 381 + ], + "score": 1.0, + "content": "case letters", + "type": "text" + }, + { + "bbox": [ + 154, + 370, + 181, + 381 + ], + "score": 0.9, + "content": "( X , Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 370, + 360, + 381 + ], + "score": 1.0, + "content": "for Boolean variables and lowercase letters", + "type": "text" + }, + { + "bbox": [ + 360, + 370, + 380, + 381 + ], + "score": 0.85, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 370, + 473, + 381 + ], + "score": 1.0, + "content": "for their instantiation", + "type": "text" + }, + { + "bbox": [ + 473, + 370, + 504, + 380 + ], + "score": 0.86, + "content": "X = 0", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 118, + 392 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 118, + 380, + 149, + 390 + ], + "score": 0.88, + "content": "X = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 380, + 349, + 392 + ], + "score": 1.0, + "content": "). Sets of variables are written in bold uppercase", + "type": "text" + }, + { + "bbox": [ + 350, + 381, + 377, + 392 + ], + "score": 0.71, + "content": "( \\mathbf { X } , \\mathbf { Y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 380, + 505, + 392 + ], + "score": 1.0, + "content": ", and their joint instantiation in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 169, + 404 + ], + "score": 1.0, + "content": "bold lowercase", + "type": "text" + }, + { + "bbox": [ + 169, + 392, + 191, + 403 + ], + "score": 0.59, + "content": "\\mathbf { \\Gamma } ( \\mathbf { x } , \\mathbf { y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 391, + 284, + 404 + ], + "score": 1.0, + "content": ". A literal is a variable", + "type": "text" + }, + { + "bbox": [ + 284, + 392, + 297, + 402 + ], + "score": 0.73, + "content": "( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 391, + 358, + 404 + ], + "score": 1.0, + "content": "or its negation", + "type": "text" + }, + { + "bbox": [ + 359, + 392, + 378, + 403 + ], + "score": 0.87, + "content": "( \\neg x )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 391, + 464, + 404 + ], + "score": 1.0, + "content": ". A logical sentence (", + "type": "text" + }, + { + "bbox": [ + 464, + 393, + 471, + 401 + ], + "score": 0.65, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 391, + 483, + 404 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 484, + 392, + 491, + 403 + ], + "score": 0.76, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 391, + 506, + 404 + ], + "score": 1.0, + "content": ") is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 402, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 380, + 414 + ], + "score": 1.0, + "content": "constructed in the usual way, from variables and logical connectives", + "type": "text" + }, + { + "bbox": [ + 380, + 403, + 402, + 413 + ], + "score": 0.47, + "content": "( \\wedge , \\vee", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 402, + 506, + 414 + ], + "score": 1.0, + "content": ", etc.), and is also called a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 264, + 425 + ], + "score": 1.0, + "content": "formula or constraint. A state or world", + "type": "text" + }, + { + "bbox": [ + 265, + 415, + 273, + 424 + ], + "score": 0.65, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 414, + 409, + 425 + ], + "score": 1.0, + "content": "is an instantiation to all variables", + "type": "text" + }, + { + "bbox": [ + 409, + 414, + 419, + 423 + ], + "score": 0.45, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 414, + 455, + 425 + ], + "score": 1.0, + "content": ". A state", + "type": "text" + }, + { + "bbox": [ + 455, + 415, + 463, + 423 + ], + "score": 0.56, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 414, + 506, + 425 + ], + "score": 1.0, + "content": "satisfies a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 143, + 436 + ], + "score": 1.0, + "content": "sentence", + "type": "text" + }, + { + "bbox": [ + 143, + 426, + 151, + 434 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 424, + 188, + 436 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 189, + 424, + 217, + 436 + ], + "score": 0.91, + "content": "\\mathbf { x } \\Vdash \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 424, + 505, + 436 + ], + "score": 1.0, + "content": ", if the sentence evaluates to be true in that world, as defined in the usual", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 174, + 447 + ], + "score": 1.0, + "content": "way. A sentence", + "type": "text" + }, + { + "bbox": [ + 174, + 437, + 182, + 445 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 435, + 279, + 447 + ], + "score": 1.0, + "content": "entails another sentence", + "type": "text" + }, + { + "bbox": [ + 280, + 435, + 287, + 446 + ], + "score": 0.81, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 435, + 324, + 447 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 325, + 435, + 353, + 447 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 435, + 449, + 447 + ], + "score": 1.0, + "content": "if all worlds that satisfy", + "type": "text" + }, + { + "bbox": [ + 450, + 437, + 457, + 445 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "also satisfy", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 446, + 493, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 114, + 458 + ], + "score": 0.82, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 446, + 164, + 459 + ], + "score": 1.0, + "content": ". A sentence", + "type": "text" + }, + { + "bbox": [ + 165, + 448, + 173, + 456 + ], + "score": 0.8, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 446, + 310, + 459 + ], + "score": 1.0, + "content": "is logically equivalent to sentence", + "type": "text" + }, + { + "bbox": [ + 311, + 446, + 318, + 458 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 446, + 356, + 459 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 356, + 446, + 383, + 458 + ], + "score": 0.91, + "content": "\\alpha \\equiv \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 446, + 415, + 459 + ], + "score": 1.0, + "content": ", if both", + "type": "text" + }, + { + "bbox": [ + 415, + 446, + 444, + 458 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 446, + 461, + 459 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 462, + 446, + 490, + 458 + ], + "score": 0.92, + "content": "\\beta \\models \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 446, + 493, + 459 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 302, + 475 + ], + "score": 1.0, + "content": "The output row vector of a neural net is denoted", + "type": "text" + }, + { + "bbox": [ + 302, + 465, + 308, + 474 + ], + "score": 0.36, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 463, + 370, + 475 + ], + "score": 1.0, + "content": ". Each value in", + "type": "text" + }, + { + "bbox": [ + 370, + 465, + 377, + 474 + ], + "score": 0.39, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "represents the probability of an", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 181, + 486 + ], + "score": 1.0, + "content": "output and falls in", + "type": "text" + }, + { + "bbox": [ + 181, + 474, + 201, + 486 + ], + "score": 0.26, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 474, + 505, + 486 + ], + "score": 1.0, + "content": ". We use both softmax and sigmoid units for our output activation functions.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 204, + 497 + ], + "score": 1.0, + "content": "The notation for states", + "type": "text" + }, + { + "bbox": [ + 204, + 487, + 212, + 495 + ], + "score": 0.5, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "is used to refer the an assignment, the logical sentence enforcing the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "assignment, or the binary vector capturing that same assignment, as these are all equivalent notions.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 512, + 505, + 634 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 506, + 526 + ], + "score": 1.0, + "content": "Figure 1 illustrates the three different concrete output constraints of varying difficulty that are studied", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 523, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 523, + 505, + 538 + ], + "score": 1.0, + "content": "in our experiments. First, we examine the exactly-one or one-hot constraint capturing the encoding", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 534, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 384, + 548 + ], + "score": 1.0, + "content": "used in multi-class classification. It states that for a set of indicators", + "type": "text" + }, + { + "bbox": [ + 384, + 535, + 466, + 547 + ], + "score": 0.92, + "content": "\\mathbf { X } = \\{ X _ { 1 } , \\ldots , X _ { n } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 534, + 506, + 548 + ], + "score": 1.0, + "content": ", one and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "score": 1.0, + "content": "exactly one of those indicators must be true, with the rest being false. This is enforced through a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 179, + 569 + ], + "score": 1.0, + "content": "logical constraint", + "type": "text" + }, + { + "bbox": [ + 179, + 559, + 187, + 567 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 556, + 338, + 569 + ], + "score": 1.0, + "content": "by conjoining sentences of the form", + "type": "text" + }, + { + "bbox": [ + 338, + 557, + 390, + 568 + ], + "score": 0.85, + "content": "\\neg X _ { 1 } \\lor \\neg X _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "for all pairs of variables (at", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 568, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 302, + 580 + ], + "score": 1.0, + "content": "most one variable is true), and a single sentence", + "type": "text" + }, + { + "bbox": [ + 302, + 568, + 365, + 579 + ], + "score": 0.89, + "content": "X _ { 1 } \\lor \\cdots \\lor X _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 568, + 506, + 580 + ], + "score": 1.0, + "content": "(at least one variable is true). Our", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "experiments further examine the valid simple path constraint. It states for a given source-destination", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 589, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 104, + 589, + 506, + 602 + ], + "score": 1.0, + "content": "pair and edge indicators, that the edge indicators which are set to true must form a valid simple path", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 601, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 613 + ], + "score": 1.0, + "content": "from source to destination. Finally, we explore the ordering constraint, which requires that a set of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 107, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 107, + 611, + 118, + 621 + ], + "score": 0.85, + "content": "n ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 611, + 316, + 624 + ], + "score": 1.0, + "content": "indicator variables represent a total ordering over", + "type": "text" + }, + { + "bbox": [ + 316, + 613, + 323, + 621 + ], + "score": 0.72, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "variables, effectively encoding a permutation", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 623, + 460, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 460, + 634 + ], + "score": 1.0, + "content": "matrix. For a full description of the path and ordering constraints, we refer to Section 5.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 108, + 650, + 211, + 664 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 213, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 213, + 666 + ], + "score": 1.0, + "content": "3 SEMANTIC LOSS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Our goal in this section is to find a semantic loss function that bridges the gap between the contin-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "uous world of neural networks, and the symbolic world of propositional logic. We do so by first", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "postulating intuitive high-level properties that we seek in such a function, and that illustrate its de-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 710, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 504, + 722 + ], + "score": 1.0, + "content": "sired behavior. A second set of postulates establish a correspondence between constraints and data.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 720, + 434, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 434, + 734 + ], + "score": 1.0, + "content": "Finally, we uniquely define the semantic loss function used throughout this paper.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 160, + 81, + 449, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 160, + 81, + 449, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 160, + 81, + 449, + 183 + ], + "spans": [ + { + "bbox": [ + 160, + 81, + 449, + 183 + ], + "score": 0.961, + "type": "image", + "image_path": "908b06431175243b10447e79ffaca6771156931dd43e1b26edd7a157a8c2ba04.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 160, + 81, + 449, + 115.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 160, + 115.0, + 449, + 149.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 160, + 149.0, + 449, + 183.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 193, + 505, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 207 + ], + "score": 1.0, + "content": "Figure 1: Outputs of a neural network feed into semantic loss functions for constraints representing", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 204, + 413, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 413, + 217 + ], + "score": 1.0, + "content": "a one-hot encoding, a total ranking of preferences, and paths in a grid graph.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 238, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 106, + 239, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 505, + 250 + ], + "score": 1.0, + "content": "Our final set of experiments study the benefits of the semantic loss function for complex structured", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 249, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 505, + 262 + ], + "score": 1.0, + "content": "output learning tasks, such as preference learning and path prediction in a graph (Daume et al., 2009; ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 505, + 272 + ], + "score": 1.0, + "content": "Chang et al., 2013; Choi et al., 2015; Graves et al., 2016). In these scenarios, the task is two-fold:", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 270, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 284 + ], + "score": 1.0, + "content": "learn both the structure of the output space, and the actual classification function within that space.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 282, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 294 + ], + "score": 1.0, + "content": "By capturing the structure of the output space with logical constraints, and minimizing the semantic", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "loss for this constraint during learning, we are able to learn networks that are much more likely to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 304, + 251, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 251, + 317 + ], + "score": 1.0, + "content": "correctly predict structured objects.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 239, + 505, + 317 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 333, + 282, + 345 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 284, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 284, + 348 + ], + "score": 1.0, + "content": "2 BACKGROUND AND NOTATION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 358, + 505, + 458 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 505, + 370 + ], + "score": 1.0, + "content": "To formally define semantic loss, we make use of concepts in propositional logic. We write upper-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 370, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 154, + 381 + ], + "score": 1.0, + "content": "case letters", + "type": "text" + }, + { + "bbox": [ + 154, + 370, + 181, + 381 + ], + "score": 0.9, + "content": "( X , Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 370, + 360, + 381 + ], + "score": 1.0, + "content": "for Boolean variables and lowercase letters", + "type": "text" + }, + { + "bbox": [ + 360, + 370, + 380, + 381 + ], + "score": 0.85, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 370, + 473, + 381 + ], + "score": 1.0, + "content": "for their instantiation", + "type": "text" + }, + { + "bbox": [ + 473, + 370, + 504, + 380 + ], + "score": 0.86, + "content": "X = 0", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 118, + 392 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 118, + 380, + 149, + 390 + ], + "score": 0.88, + "content": "X = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 380, + 349, + 392 + ], + "score": 1.0, + "content": "). Sets of variables are written in bold uppercase", + "type": "text" + }, + { + "bbox": [ + 350, + 381, + 377, + 392 + ], + "score": 0.71, + "content": "( \\mathbf { X } , \\mathbf { Y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 380, + 505, + 392 + ], + "score": 1.0, + "content": ", and their joint instantiation in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 169, + 404 + ], + "score": 1.0, + "content": "bold lowercase", + "type": "text" + }, + { + "bbox": [ + 169, + 392, + 191, + 403 + ], + "score": 0.59, + "content": "\\mathbf { \\Gamma } ( \\mathbf { x } , \\mathbf { y } )", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 391, + 284, + 404 + ], + "score": 1.0, + "content": ". A literal is a variable", + "type": "text" + }, + { + "bbox": [ + 284, + 392, + 297, + 402 + ], + "score": 0.73, + "content": "( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 391, + 358, + 404 + ], + "score": 1.0, + "content": "or its negation", + "type": "text" + }, + { + "bbox": [ + 359, + 392, + 378, + 403 + ], + "score": 0.87, + "content": "( \\neg x )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 391, + 464, + 404 + ], + "score": 1.0, + "content": ". A logical sentence (", + "type": "text" + }, + { + "bbox": [ + 464, + 393, + 471, + 401 + ], + "score": 0.65, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 391, + 483, + 404 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 484, + 392, + 491, + 403 + ], + "score": 0.76, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 391, + 506, + 404 + ], + "score": 1.0, + "content": ") is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 402, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 380, + 414 + ], + "score": 1.0, + "content": "constructed in the usual way, from variables and logical connectives", + "type": "text" + }, + { + "bbox": [ + 380, + 403, + 402, + 413 + ], + "score": 0.47, + "content": "( \\wedge , \\vee", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 402, + 506, + 414 + ], + "score": 1.0, + "content": ", etc.), and is also called a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 264, + 425 + ], + "score": 1.0, + "content": "formula or constraint. A state or world", + "type": "text" + }, + { + "bbox": [ + 265, + 415, + 273, + 424 + ], + "score": 0.65, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 414, + 409, + 425 + ], + "score": 1.0, + "content": "is an instantiation to all variables", + "type": "text" + }, + { + "bbox": [ + 409, + 414, + 419, + 423 + ], + "score": 0.45, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 414, + 455, + 425 + ], + "score": 1.0, + "content": ". A state", + "type": "text" + }, + { + "bbox": [ + 455, + 415, + 463, + 423 + ], + "score": 0.56, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 463, + 414, + 506, + 425 + ], + "score": 1.0, + "content": "satisfies a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 424, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 424, + 143, + 436 + ], + "score": 1.0, + "content": "sentence", + "type": "text" + }, + { + "bbox": [ + 143, + 426, + 151, + 434 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 424, + 188, + 436 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 189, + 424, + 217, + 436 + ], + "score": 0.91, + "content": "\\mathbf { x } \\Vdash \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 424, + 505, + 436 + ], + "score": 1.0, + "content": ", if the sentence evaluates to be true in that world, as defined in the usual", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 174, + 447 + ], + "score": 1.0, + "content": "way. A sentence", + "type": "text" + }, + { + "bbox": [ + 174, + 437, + 182, + 445 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 435, + 279, + 447 + ], + "score": 1.0, + "content": "entails another sentence", + "type": "text" + }, + { + "bbox": [ + 280, + 435, + 287, + 446 + ], + "score": 0.81, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 435, + 324, + 447 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 325, + 435, + 353, + 447 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 435, + 449, + 447 + ], + "score": 1.0, + "content": "if all worlds that satisfy", + "type": "text" + }, + { + "bbox": [ + 450, + 437, + 457, + 445 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 435, + 505, + 447 + ], + "score": 1.0, + "content": "also satisfy", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 446, + 493, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 114, + 458 + ], + "score": 0.82, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 446, + 164, + 459 + ], + "score": 1.0, + "content": ". A sentence", + "type": "text" + }, + { + "bbox": [ + 165, + 448, + 173, + 456 + ], + "score": 0.8, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 446, + 310, + 459 + ], + "score": 1.0, + "content": "is logically equivalent to sentence", + "type": "text" + }, + { + "bbox": [ + 311, + 446, + 318, + 458 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 446, + 356, + 459 + ], + "score": 1.0, + "content": ", denoted", + "type": "text" + }, + { + "bbox": [ + 356, + 446, + 383, + 458 + ], + "score": 0.91, + "content": "\\alpha \\equiv \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 446, + 415, + 459 + ], + "score": 1.0, + "content": ", if both", + "type": "text" + }, + { + "bbox": [ + 415, + 446, + 444, + 458 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 446, + 461, + 459 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 462, + 446, + 490, + 458 + ], + "score": 0.92, + "content": "\\beta \\models \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 446, + 493, + 459 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 358, + 506, + 459 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 463, + 302, + 475 + ], + "score": 1.0, + "content": "The output row vector of a neural net is denoted", + "type": "text" + }, + { + "bbox": [ + 302, + 465, + 308, + 474 + ], + "score": 0.36, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 463, + 370, + 475 + ], + "score": 1.0, + "content": ". Each value in", + "type": "text" + }, + { + "bbox": [ + 370, + 465, + 377, + 474 + ], + "score": 0.39, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "represents the probability of an", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 181, + 486 + ], + "score": 1.0, + "content": "output and falls in", + "type": "text" + }, + { + "bbox": [ + 181, + 474, + 201, + 486 + ], + "score": 0.26, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 474, + 505, + 486 + ], + "score": 1.0, + "content": ". We use both softmax and sigmoid units for our output activation functions.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 485, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 204, + 497 + ], + "score": 1.0, + "content": "The notation for states", + "type": "text" + }, + { + "bbox": [ + 204, + 487, + 212, + 495 + ], + "score": 0.5, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 485, + 505, + 497 + ], + "score": 1.0, + "content": "is used to refer the an assignment, the logical sentence enforcing the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "assignment, or the binary vector capturing that same assignment, as these are all equivalent notions.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 463, + 505, + 508 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 512, + 505, + 634 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 506, + 526 + ], + "score": 1.0, + "content": "Figure 1 illustrates the three different concrete output constraints of varying difficulty that are studied", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 523, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 104, + 523, + 505, + 538 + ], + "score": 1.0, + "content": "in our experiments. First, we examine the exactly-one or one-hot constraint capturing the encoding", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 534, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 384, + 548 + ], + "score": 1.0, + "content": "used in multi-class classification. It states that for a set of indicators", + "type": "text" + }, + { + "bbox": [ + 384, + 535, + 466, + 547 + ], + "score": 0.92, + "content": "\\mathbf { X } = \\{ X _ { 1 } , \\ldots , X _ { n } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 534, + 506, + 548 + ], + "score": 1.0, + "content": ", one and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 558 + ], + "score": 1.0, + "content": "exactly one of those indicators must be true, with the rest being false. This is enforced through a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 179, + 569 + ], + "score": 1.0, + "content": "logical constraint", + "type": "text" + }, + { + "bbox": [ + 179, + 559, + 187, + 567 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 556, + 338, + 569 + ], + "score": 1.0, + "content": "by conjoining sentences of the form", + "type": "text" + }, + { + "bbox": [ + 338, + 557, + 390, + 568 + ], + "score": 0.85, + "content": "\\neg X _ { 1 } \\lor \\neg X _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "for all pairs of variables (at", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 568, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 302, + 580 + ], + "score": 1.0, + "content": "most one variable is true), and a single sentence", + "type": "text" + }, + { + "bbox": [ + 302, + 568, + 365, + 579 + ], + "score": 0.89, + "content": "X _ { 1 } \\lor \\cdots \\lor X _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 568, + 506, + 580 + ], + "score": 1.0, + "content": "(at least one variable is true). Our", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "experiments further examine the valid simple path constraint. It states for a given source-destination", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 589, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 104, + 589, + 506, + 602 + ], + "score": 1.0, + "content": "pair and edge indicators, that the edge indicators which are set to true must form a valid simple path", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 601, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 613 + ], + "score": 1.0, + "content": "from source to destination. Finally, we explore the ordering constraint, which requires that a set of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 107, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 107, + 611, + 118, + 621 + ], + "score": 0.85, + "content": "n ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 611, + 316, + 624 + ], + "score": 1.0, + "content": "indicator variables represent a total ordering over", + "type": "text" + }, + { + "bbox": [ + 316, + 613, + 323, + 621 + ], + "score": 0.72, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "variables, effectively encoding a permutation", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 623, + 460, + 634 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 460, + 634 + ], + "score": 1.0, + "content": "matrix. For a full description of the path and ordering constraints, we refer to Section 5.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 31, + "bbox_fs": [ + 104, + 512, + 506, + 634 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 650, + 211, + 664 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 213, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 213, + 666 + ], + "score": 1.0, + "content": "3 SEMANTIC LOSS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "Our goal in this section is to find a semantic loss function that bridges the gap between the contin-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "uous world of neural networks, and the symbolic world of propositional logic. We do so by first", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "postulating intuitive high-level properties that we seek in such a function, and that illustrate its de-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 710, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 504, + 722 + ], + "score": 1.0, + "content": "sired behavior. A second set of postulates establish a correspondence between constraints and data.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 720, + 434, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 434, + 734 + ], + "score": 1.0, + "content": "Finally, we uniquely define the semantic loss function used throughout this paper.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 677, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 179, + 95 + ], + "score": 1.0, + "content": "The semantic loss", + "type": "text" + }, + { + "bbox": [ + 179, + 82, + 214, + 94 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 82, + 318, + 95 + ], + "score": 1.0, + "content": "is a function of a sentence", + "type": "text" + }, + { + "bbox": [ + 318, + 84, + 326, + 92 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "in propositional logic, defined over variables", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 92, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 107, + 93, + 189, + 106 + ], + "score": 0.92, + "content": "\\mathbf { X } = \\{ X _ { 1 } , \\ldots , X _ { n } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 92, + 309, + 108 + ], + "score": 1.0, + "content": ", and a vector of probabilities", + "type": "text" + }, + { + "bbox": [ + 309, + 96, + 317, + 105 + ], + "score": 0.54, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 92, + 460, + 108 + ], + "score": 1.0, + "content": "for the same variables X. Element", + "type": "text" + }, + { + "bbox": [ + 460, + 95, + 470, + 105 + ], + "score": 0.85, + "content": "{ \\mathsf p } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 92, + 506, + 108 + ], + "score": 1.0, + "content": "denotes", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 255, + 116 + ], + "score": 1.0, + "content": "the predicted probability of variable", + "type": "text" + }, + { + "bbox": [ + 255, + 105, + 267, + 115 + ], + "score": 0.89, + "content": "X _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 105, + 505, + 116 + ], + "score": 1.0, + "content": ", and corresponds to a single output of the neural net. For", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "example, the semantic loss between the one-hot constraint from the previous section, and a neural", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 176, + 139 + ], + "score": 1.0, + "content": "net output vector", + "type": "text" + }, + { + "bbox": [ + 176, + 128, + 182, + 138 + ], + "score": 0.54, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 126, + 505, + 139 + ], + "score": 1.0, + "content": ", is intended to capture how close the prediction p is to having exactly one output", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 491, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 491, + 149 + ], + "score": 1.0, + "content": "set to true (that is, 1), and all others set to false (that is, 0), regardless of which output is correct.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 107, + 162, + 243, + 173 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 244, + 174 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 244, + 174 + ], + "score": 1.0, + "content": "3.1 HIGH-LEVEL PROPERTIES", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 182, + 504, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 381, + 195 + ], + "score": 1.0, + "content": "The first axiom says that there is no loss when the logical constraint", + "type": "text" + }, + { + "bbox": [ + 381, + 185, + 389, + 192 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 182, + 505, + 195 + ], + "score": 1.0, + "content": "is always true (it is a logical", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 192, + 332, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 332, + 208 + ], + "score": 1.0, + "content": "tautology), independent of the predicted probabilities p.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 109, + 208, + 444, + 220 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 443, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 358, + 222 + ], + "score": 1.0, + "content": "Axiom 1 (Truth). The semantic loss of a true sentence is zero:", + "type": "text" + }, + { + "bbox": [ + 359, + 208, + 440, + 221 + ], + "score": 0.82, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } ) = 0 .", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 207, + 443, + 222 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 226, + 505, + 248 + ], + "lines": [ + { + "bbox": [ + 105, + 225, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 505, + 239 + ], + "score": 1.0, + "content": "Next, when enforcing two constraints on disjoint sets of variables, we want the ability to compute", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 236, + 504, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 504, + 249 + ], + "score": 1.0, + "content": "the semantic loss of the two constraints separately, and sum the results for their joint semantic loss.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 251, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 270, + 264 + ], + "score": 1.0, + "content": "Axiom 2 (Additive Independence). Let", + "type": "text" + }, + { + "bbox": [ + 271, + 253, + 279, + 261 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 250, + 359, + 264 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 360, + 252, + 370, + 262 + ], + "score": 0.39, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 250, + 445, + 264 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 446, + 253, + 452, + 263 + ], + "score": 0.5, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 250, + 475, + 264 + ], + "score": 1.0, + "content": ". Let", + "type": "text" + }, + { + "bbox": [ + 476, + 252, + 483, + 263 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "be a", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 504, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 164, + 275 + ], + "score": 1.0, + "content": "sentence over", + "type": "text" + }, + { + "bbox": [ + 164, + 263, + 175, + 273 + ], + "score": 0.44, + "content": "\\mathbf { Y }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 262, + 231, + 275 + ], + "score": 1.0, + "content": "disjoint from", + "type": "text" + }, + { + "bbox": [ + 231, + 263, + 241, + 272 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 262, + 316, + 275 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 317, + 264, + 323, + 274 + ], + "score": 0.25, + "content": "\\mathsf { q }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 262, + 478, + 275 + ], + "score": 1.0, + "content": ". The semantic loss between sentence", + "type": "text" + }, + { + "bbox": [ + 478, + 263, + 504, + 273 + ], + "score": 0.86, + "content": "\\alpha \\wedge \\beta", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 347, + 286 + ], + "score": 1.0, + "content": "and the joint probability vector [p q] decomposes additively:", + "type": "text" + }, + { + "bbox": [ + 347, + 273, + 501, + 286 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha \\wedge \\beta , [ { \\mathsf { p q } } ] ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) + \\operatorname { L } ^ { \\mathrm { s } } ( \\beta , { \\mathsf { q } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 273, + 505, + 286 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 504, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 290, + 504, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 504, + 302 + ], + "score": 1.0, + "content": "It directly follows from Axioms 1 and 2 that the probabilities of variables that are not used on the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 302, + 492, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 492, + 314 + ], + "score": 1.0, + "content": "constraint do not affect the semantic loss. Proposition 6 in Appendix A formalizes this intuition.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 502, + 330 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "To maintain logical meaning, we postulate that semantic loss is monotone in the order of implication.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 496, + 345 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 495, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 222, + 348 + ], + "score": 1.0, + "content": "Axiom 3 (Monotonicity). If", + "type": "text" + }, + { + "bbox": [ + 222, + 333, + 250, + 345 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 330, + 344, + 348 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 344, + 333, + 426, + 345 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) \\geq \\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 330, + 485, + 348 + ], + "score": 1.0, + "content": "for any vector", + "type": "text" + }, + { + "bbox": [ + 485, + 336, + 492, + 345 + ], + "score": 0.27, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 330, + 495, + 348 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 350, + 505, + 395 + ], + "lines": [ + { + "bbox": [ + 105, + 350, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 427, + 363 + ], + "score": 1.0, + "content": "Intuitively, as we add stricter requirements to the logical constraint, going from", + "type": "text" + }, + { + "bbox": [ + 427, + 351, + 435, + 362 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 350, + 446, + 363 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 446, + 353, + 454, + 361 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 350, + 505, + 363 + ], + "score": 1.0, + "content": "and making", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 362, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 405, + 374 + ], + "score": 1.0, + "content": "it harder to satisfy, the semantic loss cannot decrease. For example, when", + "type": "text" + }, + { + "bbox": [ + 406, + 362, + 414, + 373 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 362, + 506, + 374 + ], + "score": 1.0, + "content": "enforces the output of", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 444, + 385 + ], + "score": 1.0, + "content": "an neural network to encode a subtree of a graph, and we tighten that requirement in", + "type": "text" + }, + { + "bbox": [ + 445, + 375, + 453, + 383 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "to be a path,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 383, + 504, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 422, + 396 + ], + "score": 1.0, + "content": "the semantic loss cannot decrease. Every path is also a tree and any solution to", + "type": "text" + }, + { + "bbox": [ + 423, + 385, + 430, + 393 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 383, + 492, + 396 + ], + "score": 1.0, + "content": "is a solution to", + "type": "text" + }, + { + "bbox": [ + 492, + 384, + 499, + 395 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 383, + 504, + 396 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 400, + 504, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "score": 1.0, + "content": "A first consequence following the monotonicity axiom is that logically equivalent sentences must", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 411, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 423 + ], + "score": 1.0, + "content": "incur an identical semantic loss for the same probability vector p. Hence, the semantic loss is indeed", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 422, + 486, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 486, + 435 + ], + "score": 1.0, + "content": "a semantic property of the logical sentence, and does not depend on the syntax of the sentence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 108, + 436, + 450, + 449 + ], + "lines": [ + { + "bbox": [ + 105, + 435, + 452, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 179, + 452 + ], + "score": 1.0, + "content": "Proposition 1. If", + "type": "text" + }, + { + "bbox": [ + 179, + 437, + 206, + 449 + ], + "score": 0.9, + "content": "\\alpha \\equiv \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 435, + 300, + 452 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 300, + 437, + 382, + 449 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) = \\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 435, + 452, + 452 + ], + "score": 1.0, + "content": "for any vector p.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 503, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 504, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 504, + 468 + ], + "score": 1.0, + "content": "A second consequence is that semantic loss must be non-negative (see Proposition 5 in Appendix A).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 108, + 479, + 289, + 491 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 290, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 290, + 492 + ], + "score": 1.0, + "content": "3.2 DATA-SENTENCE CORRESPONDENCE", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 499, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 137, + 513 + ], + "score": 1.0, + "content": "A state", + "type": "text" + }, + { + "bbox": [ + 137, + 502, + 145, + 510 + ], + "score": 0.63, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 499, + 505, + 513 + ], + "score": 1.0, + "content": "is equivalently represented as a data vector, as well as a logical constraint that enforces a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 213, + 523 + ], + "score": 1.0, + "content": "value for every variable in", + "type": "text" + }, + { + "bbox": [ + 213, + 511, + 223, + 521 + ], + "score": 0.27, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 511, + 505, + 523 + ], + "score": 1.0, + "content": ". When both the constraint and the predicted vector represent the same", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 522, + 433, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 183, + 534 + ], + "score": 1.0, + "content": "state (for example,", + "type": "text" + }, + { + "bbox": [ + 183, + 522, + 251, + 533 + ], + "score": 0.92, + "content": "X _ { 1 } \\wedge { \\neg { X _ { 2 } } } \\wedge X _ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 522, + 433, + 534 + ], + "score": 1.0, + "content": "vs. [1 0 1]), there should be no semantic loss.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 104, + 537, + 504, + 559 + ], + "lines": [ + { + "bbox": [ + 105, + 534, + 506, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 250, + 551 + ], + "score": 1.0, + "content": "Axiom 4 (Identity). For any state", + "type": "text" + }, + { + "bbox": [ + 250, + 539, + 258, + 547 + ], + "score": 0.59, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 534, + 506, + 551 + ], + "score": 1.0, + "content": ", there is zero semantic loss between its representation as a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 547, + 410, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 336, + 560 + ], + "score": 1.0, + "content": "sentence, and its representation as a deterministic vector:", + "type": "text" + }, + { + "bbox": [ + 336, + 547, + 406, + 560 + ], + "score": 0.92, + "content": "\\forall \\mathbf { x } , \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathbf { x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 547, + 410, + 560 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 598 + ], + "lines": [ + { + "bbox": [ + 105, + 564, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 506, + 578 + ], + "score": 1.0, + "content": "The axioms above together imply that any vector satisfying the constraint must incur zero loss. For", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 575, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 229, + 590 + ], + "score": 1.0, + "content": "example, when our constraint", + "type": "text" + }, + { + "bbox": [ + 229, + 578, + 237, + 586 + ], + "score": 0.74, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 575, + 505, + 590 + ], + "score": 1.0, + "content": "requires that the output vector encodes an arbitrary total ranking,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 587, + 479, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 165, + 599 + ], + "score": 1.0, + "content": "and the vector", + "type": "text" + }, + { + "bbox": [ + 165, + 589, + 173, + 597 + ], + "score": 0.28, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 587, + 479, + 599 + ], + "score": 1.0, + "content": "correctly represents a single specific total ranking, there is no semantic loss.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 108, + 601, + 414, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 600, + 414, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 235, + 615 + ], + "score": 1.0, + "content": "Proposition 2 (Satisfaction). If", + "type": "text" + }, + { + "bbox": [ + 235, + 601, + 263, + 614 + ], + "score": 0.82, + "content": "\\mathbf { \\dot { x } } \\Vdash \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 600, + 357, + 615 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 357, + 601, + 411, + 614 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 600, + 414, + 615 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 108, + 619, + 507, + 652 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 242, + 632 + ], + "score": 1.0, + "content": "As a special case, logical literals", + "type": "text" + }, + { + "bbox": [ + 243, + 621, + 249, + 629 + ], + "score": 0.55, + "content": "\\scriptstyle { \\dot { x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 618, + 261, + 632 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 261, + 621, + 275, + 630 + ], + "score": 0.77, + "content": "\\neg x", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 618, + 506, + 632 + ], + "score": 1.0, + "content": ") constrain a single variable to take on a single value, and", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 630, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 506, + 642 + ], + "score": 1.0, + "content": "thus play a role similar to the labels used in supervised learning. Such constraints require an even", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "tighter correspondence: the semantic loss must act like a classical loss function (i.e., cross entropy).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 105, + 655, + 504, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "Axiom 5 (Label-Literal Correspondence). The semantic loss of a single literal is proportionate to the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 296, + 680 + ], + "score": 1.0, + "content": "cross-entropy loss for the equivalent data label:", + "type": "text" + }, + { + "bbox": [ + 297, + 666, + 379, + 678 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( x , p ) \\propto - \\log ( p )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 666, + 396, + 680 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 397, + 666, + 501, + 678 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\neg { x } , \\bar { p } ) \\overset { \\cdot } { \\propto } - \\log ( 1 - p )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 666, + 505, + 680 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 108, + 684, + 503, + 717 + ], + "lines": [ + { + "bbox": [ + 106, + 684, + 505, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 505, + 697 + ], + "score": 1.0, + "content": "Appendix A states Axioms 7 and 8, on the symmetry between values and the symmetry between", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 695, + 505, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 695, + 505, + 707 + ], + "score": 1.0, + "content": "variables, as well as a Lemma 7 that ties together the multiplicative constants mentioned in Axiom 5.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 705, + 443, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 705, + 431, + 718 + ], + "score": 1.0, + "content": "Finally, this allows us to prove the following form of the semantic loss for a state", + "type": "text" + }, + { + "bbox": [ + 431, + 708, + 439, + 716 + ], + "score": 0.71, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 705, + 443, + 718 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 105, + 720, + 502, + 734 + ], + "lines": [ + { + "bbox": [ + 104, + 718, + 502, + 736 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 285, + 736 + ], + "score": 1.0, + "content": "Lemma 3. For state x and vector p, we have", + "type": "text" + }, + { + "bbox": [ + 285, + 719, + 502, + 735 + ], + "score": 0.81, + "content": "\\begin{array} { r } { \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathsf { p } ) \\propto - \\sum _ { i : \\mathbf { x } | = X _ { i } } \\log \\mathsf { p } _ { i } - \\sum _ { i : \\mathbf { x } | = \\lnot X _ { i } } \\log ( 1 - \\mathsf { p } _ { i } ) . } \\end{array}", + "type": "inline_equation" + } + ], + "index": 46 + } + ], + "index": 46 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 179, + 95 + ], + "score": 1.0, + "content": "The semantic loss", + "type": "text" + }, + { + "bbox": [ + 179, + 82, + 214, + 94 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 82, + 318, + 95 + ], + "score": 1.0, + "content": "is a function of a sentence", + "type": "text" + }, + { + "bbox": [ + 318, + 84, + 326, + 92 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "in propositional logic, defined over variables", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 92, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 107, + 93, + 189, + 106 + ], + "score": 0.92, + "content": "\\mathbf { X } = \\{ X _ { 1 } , \\ldots , X _ { n } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 92, + 309, + 108 + ], + "score": 1.0, + "content": ", and a vector of probabilities", + "type": "text" + }, + { + "bbox": [ + 309, + 96, + 317, + 105 + ], + "score": 0.54, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 92, + 460, + 108 + ], + "score": 1.0, + "content": "for the same variables X. Element", + "type": "text" + }, + { + "bbox": [ + 460, + 95, + 470, + 105 + ], + "score": 0.85, + "content": "{ \\mathsf p } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 92, + 506, + 108 + ], + "score": 1.0, + "content": "denotes", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 255, + 116 + ], + "score": 1.0, + "content": "the predicted probability of variable", + "type": "text" + }, + { + "bbox": [ + 255, + 105, + 267, + 115 + ], + "score": 0.89, + "content": "X _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 105, + 505, + 116 + ], + "score": 1.0, + "content": ", and corresponds to a single output of the neural net. For", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "example, the semantic loss between the one-hot constraint from the previous section, and a neural", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 176, + 139 + ], + "score": 1.0, + "content": "net output vector", + "type": "text" + }, + { + "bbox": [ + 176, + 128, + 182, + 138 + ], + "score": 0.54, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 126, + 505, + 139 + ], + "score": 1.0, + "content": ", is intended to capture how close the prediction p is to having exactly one output", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 138, + 491, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 491, + 149 + ], + "score": 1.0, + "content": "set to true (that is, 1), and all others set to false (that is, 0), regardless of which output is correct.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 506, + 149 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 162, + 243, + 173 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 244, + 174 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 244, + 174 + ], + "score": 1.0, + "content": "3.1 HIGH-LEVEL PROPERTIES", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 182, + 504, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 381, + 195 + ], + "score": 1.0, + "content": "The first axiom says that there is no loss when the logical constraint", + "type": "text" + }, + { + "bbox": [ + 381, + 185, + 389, + 192 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 182, + 505, + 195 + ], + "score": 1.0, + "content": "is always true (it is a logical", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 192, + 332, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 332, + 208 + ], + "score": 1.0, + "content": "tautology), independent of the predicted probabilities p.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 182, + 505, + 208 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 208, + 444, + 220 + ], + "lines": [ + { + "bbox": [ + 106, + 207, + 443, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 358, + 222 + ], + "score": 1.0, + "content": "Axiom 1 (Truth). The semantic loss of a true sentence is zero:", + "type": "text" + }, + { + "bbox": [ + 359, + 208, + 440, + 221 + ], + "score": 0.82, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } ) = 0 .", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 207, + 443, + 222 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9, + "bbox_fs": [ + 106, + 207, + 443, + 222 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 226, + 505, + 248 + ], + "lines": [ + { + "bbox": [ + 105, + 225, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 505, + 239 + ], + "score": 1.0, + "content": "Next, when enforcing two constraints on disjoint sets of variables, we want the ability to compute", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 236, + 504, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 504, + 249 + ], + "score": 1.0, + "content": "the semantic loss of the two constraints separately, and sum the results for their joint semantic loss.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 225, + 505, + 249 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 251, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 270, + 264 + ], + "score": 1.0, + "content": "Axiom 2 (Additive Independence). Let", + "type": "text" + }, + { + "bbox": [ + 271, + 253, + 279, + 261 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 250, + 359, + 264 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 360, + 252, + 370, + 262 + ], + "score": 0.39, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 250, + 445, + 264 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 446, + 253, + 452, + 263 + ], + "score": 0.5, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 250, + 475, + 264 + ], + "score": 1.0, + "content": ". Let", + "type": "text" + }, + { + "bbox": [ + 476, + 252, + 483, + 263 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "be a", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 504, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 164, + 275 + ], + "score": 1.0, + "content": "sentence over", + "type": "text" + }, + { + "bbox": [ + 164, + 263, + 175, + 273 + ], + "score": 0.44, + "content": "\\mathbf { Y }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 262, + 231, + 275 + ], + "score": 1.0, + "content": "disjoint from", + "type": "text" + }, + { + "bbox": [ + 231, + 263, + 241, + 272 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 262, + 316, + 275 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 317, + 264, + 323, + 274 + ], + "score": 0.25, + "content": "\\mathsf { q }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 262, + 478, + 275 + ], + "score": 1.0, + "content": ". The semantic loss between sentence", + "type": "text" + }, + { + "bbox": [ + 478, + 263, + 504, + 273 + ], + "score": 0.86, + "content": "\\alpha \\wedge \\beta", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 347, + 286 + ], + "score": 1.0, + "content": "and the joint probability vector [p q] decomposes additively:", + "type": "text" + }, + { + "bbox": [ + 347, + 273, + 501, + 286 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha \\wedge \\beta , [ { \\mathsf { p q } } ] ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) + \\operatorname { L } ^ { \\mathrm { s } } ( \\beta , { \\mathsf { q } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 273, + 505, + 286 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 250, + 507, + 286 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 290, + 504, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 290, + 504, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 504, + 302 + ], + "score": 1.0, + "content": "It directly follows from Axioms 1 and 2 that the probabilities of variables that are not used on the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 302, + 492, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 492, + 314 + ], + "score": 1.0, + "content": "constraint do not affect the semantic loss. Proposition 6 in Appendix A formalizes this intuition.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 290, + 504, + 314 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 502, + 330 + ], + "lines": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "To maintain logical meaning, we postulate that semantic loss is monotone in the order of implication.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17, + "bbox_fs": [ + 106, + 318, + 504, + 331 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 333, + 496, + 345 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 495, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 222, + 348 + ], + "score": 1.0, + "content": "Axiom 3 (Monotonicity). If", + "type": "text" + }, + { + "bbox": [ + 222, + 333, + 250, + 345 + ], + "score": 0.91, + "content": "\\alpha \\models \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 251, + 330, + 344, + 348 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 344, + 333, + 426, + 345 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) \\geq \\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 330, + 485, + 348 + ], + "score": 1.0, + "content": "for any vector", + "type": "text" + }, + { + "bbox": [ + 485, + 336, + 492, + 345 + ], + "score": 0.27, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 330, + 495, + 348 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 330, + 495, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 350, + 505, + 395 + ], + "lines": [ + { + "bbox": [ + 105, + 350, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 427, + 363 + ], + "score": 1.0, + "content": "Intuitively, as we add stricter requirements to the logical constraint, going from", + "type": "text" + }, + { + "bbox": [ + 427, + 351, + 435, + 362 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 350, + 446, + 363 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 446, + 353, + 454, + 361 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 350, + 505, + 363 + ], + "score": 1.0, + "content": "and making", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 362, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 405, + 374 + ], + "score": 1.0, + "content": "it harder to satisfy, the semantic loss cannot decrease. For example, when", + "type": "text" + }, + { + "bbox": [ + 406, + 362, + 414, + 373 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 362, + 506, + 374 + ], + "score": 1.0, + "content": "enforces the output of", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 444, + 385 + ], + "score": 1.0, + "content": "an neural network to encode a subtree of a graph, and we tighten that requirement in", + "type": "text" + }, + { + "bbox": [ + 445, + 375, + 453, + 383 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "to be a path,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 383, + 504, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 422, + 396 + ], + "score": 1.0, + "content": "the semantic loss cannot decrease. Every path is also a tree and any solution to", + "type": "text" + }, + { + "bbox": [ + 423, + 385, + 430, + 393 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 383, + 492, + 396 + ], + "score": 1.0, + "content": "is a solution to", + "type": "text" + }, + { + "bbox": [ + 492, + 384, + 499, + 395 + ], + "score": 0.84, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 383, + 504, + 396 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 350, + 506, + 396 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 400, + 504, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "score": 1.0, + "content": "A first consequence following the monotonicity axiom is that logically equivalent sentences must", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 411, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 423 + ], + "score": 1.0, + "content": "incur an identical semantic loss for the same probability vector p. Hence, the semantic loss is indeed", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 422, + 486, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 486, + 435 + ], + "score": 1.0, + "content": "a semantic property of the logical sentence, and does not depend on the syntax of the sentence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 400, + 506, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 436, + 450, + 449 + ], + "lines": [ + { + "bbox": [ + 105, + 435, + 452, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 179, + 452 + ], + "score": 1.0, + "content": "Proposition 1. If", + "type": "text" + }, + { + "bbox": [ + 179, + 437, + 206, + 449 + ], + "score": 0.9, + "content": "\\alpha \\equiv \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 435, + 300, + 452 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 300, + 437, + 382, + 449 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) = \\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 435, + 452, + 452 + ], + "score": 1.0, + "content": "for any vector p.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 435, + 452, + 452 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 503, + 466 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 504, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 504, + 468 + ], + "score": 1.0, + "content": "A second consequence is that semantic loss must be non-negative (see Proposition 5 in Appendix A).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 453, + 504, + 468 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 479, + 289, + 491 + ], + "lines": [ + { + "bbox": [ + 106, + 479, + 290, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 290, + 492 + ], + "score": 1.0, + "content": "3.2 DATA-SENTENCE CORRESPONDENCE", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 499, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 137, + 513 + ], + "score": 1.0, + "content": "A state", + "type": "text" + }, + { + "bbox": [ + 137, + 502, + 145, + 510 + ], + "score": 0.63, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 499, + 505, + 513 + ], + "score": 1.0, + "content": "is equivalently represented as a data vector, as well as a logical constraint that enforces a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 213, + 523 + ], + "score": 1.0, + "content": "value for every variable in", + "type": "text" + }, + { + "bbox": [ + 213, + 511, + 223, + 521 + ], + "score": 0.27, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 511, + 505, + 523 + ], + "score": 1.0, + "content": ". When both the constraint and the predicted vector represent the same", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 522, + 433, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 183, + 534 + ], + "score": 1.0, + "content": "state (for example,", + "type": "text" + }, + { + "bbox": [ + 183, + 522, + 251, + 533 + ], + "score": 0.92, + "content": "X _ { 1 } \\wedge { \\neg { X _ { 2 } } } \\wedge X _ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 522, + 433, + 534 + ], + "score": 1.0, + "content": "vs. [1 0 1]), there should be no semantic loss.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 499, + 505, + 534 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 537, + 504, + 559 + ], + "lines": [ + { + "bbox": [ + 105, + 534, + 506, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 250, + 551 + ], + "score": 1.0, + "content": "Axiom 4 (Identity). For any state", + "type": "text" + }, + { + "bbox": [ + 250, + 539, + 258, + 547 + ], + "score": 0.59, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 534, + 506, + 551 + ], + "score": 1.0, + "content": ", there is zero semantic loss between its representation as a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 547, + 410, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 336, + 560 + ], + "score": 1.0, + "content": "sentence, and its representation as a deterministic vector:", + "type": "text" + }, + { + "bbox": [ + 336, + 547, + 406, + 560 + ], + "score": 0.92, + "content": "\\forall \\mathbf { x } , \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathbf { x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 547, + 410, + 560 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 534, + 506, + 560 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 598 + ], + "lines": [ + { + "bbox": [ + 105, + 564, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 506, + 578 + ], + "score": 1.0, + "content": "The axioms above together imply that any vector satisfying the constraint must incur zero loss. For", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 575, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 229, + 590 + ], + "score": 1.0, + "content": "example, when our constraint", + "type": "text" + }, + { + "bbox": [ + 229, + 578, + 237, + 586 + ], + "score": 0.74, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 575, + 505, + 590 + ], + "score": 1.0, + "content": "requires that the output vector encodes an arbitrary total ranking,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 587, + 479, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 165, + 599 + ], + "score": 1.0, + "content": "and the vector", + "type": "text" + }, + { + "bbox": [ + 165, + 589, + 173, + 597 + ], + "score": 0.28, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 587, + 479, + 599 + ], + "score": 1.0, + "content": "correctly represents a single specific total ranking, there is no semantic loss.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 564, + 506, + 599 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 601, + 414, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 600, + 414, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 235, + 615 + ], + "score": 1.0, + "content": "Proposition 2 (Satisfaction). If", + "type": "text" + }, + { + "bbox": [ + 235, + 601, + 263, + 614 + ], + "score": 0.82, + "content": "\\mathbf { \\dot { x } } \\Vdash \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 600, + 357, + 615 + ], + "score": 1.0, + "content": ", then the semantic loss", + "type": "text" + }, + { + "bbox": [ + 357, + 601, + 411, + 614 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 600, + 414, + 615 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 600, + 414, + 615 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 619, + 507, + 652 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 242, + 632 + ], + "score": 1.0, + "content": "As a special case, logical literals", + "type": "text" + }, + { + "bbox": [ + 243, + 621, + 249, + 629 + ], + "score": 0.55, + "content": "\\scriptstyle { \\dot { x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 618, + 261, + 632 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 261, + 621, + 275, + 630 + ], + "score": 0.77, + "content": "\\neg x", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 618, + 506, + 632 + ], + "score": 1.0, + "content": ") constrain a single variable to take on a single value, and", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 630, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 506, + 642 + ], + "score": 1.0, + "content": "thus play a role similar to the labels used in supervised learning. Such constraints require an even", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "tighter correspondence: the semantic loss must act like a classical loss function (i.e., cross entropy).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 618, + 506, + 654 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 655, + 504, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "Axiom 5 (Label-Literal Correspondence). The semantic loss of a single literal is proportionate to the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 296, + 680 + ], + "score": 1.0, + "content": "cross-entropy loss for the equivalent data label:", + "type": "text" + }, + { + "bbox": [ + 297, + 666, + 379, + 678 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( x , p ) \\propto - \\log ( p )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 666, + 396, + 680 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 397, + 666, + 501, + 678 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\neg { x } , \\bar { p } ) \\overset { \\cdot } { \\propto } - \\log ( 1 - p )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 666, + 505, + 680 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 655, + 505, + 680 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 684, + 503, + 717 + ], + "lines": [ + { + "bbox": [ + 106, + 684, + 505, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 505, + 697 + ], + "score": 1.0, + "content": "Appendix A states Axioms 7 and 8, on the symmetry between values and the symmetry between", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 695, + 505, + 707 + ], + "spans": [ + { + "bbox": [ + 106, + 695, + 505, + 707 + ], + "score": 1.0, + "content": "variables, as well as a Lemma 7 that ties together the multiplicative constants mentioned in Axiom 5.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 705, + 443, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 705, + 431, + 718 + ], + "score": 1.0, + "content": "Finally, this allows us to prove the following form of the semantic loss for a state", + "type": "text" + }, + { + "bbox": [ + 431, + 708, + 439, + 716 + ], + "score": 0.71, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 705, + 443, + 718 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 684, + 505, + 718 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 720, + 502, + 734 + ], + "lines": [ + { + "bbox": [ + 104, + 718, + 502, + 736 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 285, + 736 + ], + "score": 1.0, + "content": "Lemma 3. For state x and vector p, we have", + "type": "text" + }, + { + "bbox": [ + 285, + 719, + 502, + 735 + ], + "score": 0.81, + "content": "\\begin{array} { r } { \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathsf { p } ) \\propto - \\sum _ { i : \\mathbf { x } | = X _ { i } } \\log \\mathsf { p } _ { i } - \\sum _ { i : \\mathbf { x } | = \\lnot X _ { i } } \\log ( 1 - \\mathsf { p } _ { i } ) . } \\end{array}", + "type": "inline_equation" + } + ], + "index": 46 + } + ], + "index": 46, + "bbox_fs": [ + 104, + 718, + 502, + 736 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 150, + 89, + 452, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 150, + 89, + 452, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 150, + 89, + 452, + 183 + ], + "spans": [ + { + "bbox": [ + 150, + 89, + 452, + 183 + ], + "score": 0.686, + "type": "image", + "image_path": "5fcbfe708dc5ef9963d1119ec14ca3d17f5eace11a8e49df2a20fcaf583e6a6f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 150, + 89, + 452, + 120.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 150, + 120.33333333333333, + 452, + 151.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 150, + 151.66666666666666, + 452, + 183.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 116, + 191, + 493, + 204 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 191, + 494, + 204 + ], + "spans": [ + { + "bbox": [ + 116, + 191, + 494, + 204 + ], + "score": 1.0, + "content": "Figure 2: Binary classification toy example: a linear classifier without and with semantic loss.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 107, + 226, + 237, + 237 + ], + "lines": [ + { + "bbox": [ + 105, + 225, + 239, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 239, + 239 + ], + "score": 1.0, + "content": "3.3 A GENERAL DEFINITION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 504, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "Lemma 3 falls short as a full definition of semantic loss for arbitrary sentences. One can define", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 258, + 461, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 230, + 271 + ], + "score": 1.0, + "content": "additional axioms to pin down", + "type": "text" + }, + { + "bbox": [ + 230, + 258, + 241, + 268 + ], + "score": 0.58, + "content": "\\mathrm { L } ^ { \\mathrm { s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 258, + 461, + 271 + ], + "score": 1.0, + "content": ". For example, the following axiom is highly desirable.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 502, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 503, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 279, + 286 + ], + "score": 1.0, + "content": "Axiom 6 (Differentiability). For any fixed", + "type": "text" + }, + { + "bbox": [ + 279, + 276, + 287, + 284 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 273, + 361, + 286 + ], + "score": 1.0, + "content": ", the semantic loss", + "type": "text" + }, + { + "bbox": [ + 362, + 274, + 396, + 286 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 273, + 503, + 286 + ], + "score": 1.0, + "content": "is monotone in each prob-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 285, + 276, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 276, + 296 + ], + "score": 1.0, + "content": "ability in p, continuous and differentiable.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 302, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "Appendix A makes the notion of semantic loss precise by stating one additional axiom. It is based", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 313, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 505, + 325 + ], + "score": 1.0, + "content": "on the observation that the state loss of Lemma 3 is proportionate to a log-probability. In particular,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 316, + 336 + ], + "score": 1.0, + "content": "it corresponds to the probability of obtaining state", + "type": "text" + }, + { + "bbox": [ + 316, + 326, + 325, + 334 + ], + "score": 0.51, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 324, + 469, + 336 + ], + "score": 1.0, + "content": "after independently sampling each", + "type": "text" + }, + { + "bbox": [ + 470, + 325, + 483, + 335 + ], + "score": 0.88, + "content": "X _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 335, + 488, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 152, + 348 + ], + "score": 1.0, + "content": "probability", + "type": "text" + }, + { + "bbox": [ + 153, + 336, + 162, + 347 + ], + "score": 0.83, + "content": "{ \\mathsf { p } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 335, + 488, + 348 + ], + "score": 1.0, + "content": ". We have now derived the semantic loss function from first principles as follows.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 104, + 350, + 504, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 350, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 246, + 363 + ], + "score": 1.0, + "content": "Definition 1 (Semantic Loss). Let", + "type": "text" + }, + { + "bbox": [ + 247, + 353, + 253, + 362 + ], + "score": 0.29, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 350, + 462, + 363 + ], + "score": 1.0, + "content": "be a vector of probabilities, one for each variable in", + "type": "text" + }, + { + "bbox": [ + 462, + 351, + 472, + 361 + ], + "score": 0.73, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 350, + 505, + 363 + ], + "score": 1.0, + "content": ", and let", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 361, + 358, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 114, + 372 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 361, + 191, + 375 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 191, + 362, + 201, + 372 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 361, + 315, + 375 + ], + "score": 1.0, + "content": ". The semantic loss between", + "type": "text" + }, + { + "bbox": [ + 315, + 364, + 322, + 372 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 361, + 340, + 375 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 340, + 364, + 347, + 373 + ], + "score": 0.7, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 361, + 358, + 375 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 379, + 411, + 408 + ], + "lines": [ + { + "bbox": [ + 199, + 379, + 411, + 408 + ], + "spans": [ + { + "bbox": [ + 199, + 379, + 411, + 408 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathfrak { p } ) \\propto - \\log \\sum _ { \\mathbf { x } \\in \\alpha } \\ \\prod _ { i : \\mathbf { x } | = X _ { i } } \\mathfrak { p } _ { i } \\prod _ { i : \\mathbf { x } | = \\ l - X _ { i } } ( 1 - \\mathfrak { p } _ { i } ) .", + "type": "interline_equation", + "image_path": "5cdaa907f91cf65ce0836950e29b48878daf757f6c8fdd7e1bf203317f92f496.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 379, + 411, + 393.5 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 199, + 393.5, + 411, + 408.0 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 415, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 428 + ], + "score": 1.0, + "content": "Theorem 4 (Uniqueness). The semantic loss function in Definition 1 satisfies Axioms 1–9 and is the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 425, + 339, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 339, + 438 + ], + "score": 1.0, + "content": "only function that does so, up to a multiplicative constant.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Intuitively, the semantic loss is proportionate to a negative logarithm of the probability of generating", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 104, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "a state that satisfies the constraint, when sampling values according to p. Hence, it is the self-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 465, + 493, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 493, + 477 + ], + "score": 1.0, + "content": "information (or “surprise”) of obtaining an assignment that satisfies the constraint (Jones, 1979).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "title", + "bbox": [ + 107, + 494, + 311, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 312, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 312, + 509 + ], + "score": 1.0, + "content": "4 SEMI-SUPERVISED CLASSIFICATION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "score": 1.0, + "content": "The most straightforward constraint that is ubiquitous in multi-class classification is mutual exclu-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "sion over one-hot-encoded outputs. That is, for a given example, exactly one class and therefore", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "score": 1.0, + "content": "exactly one binary indicator must be true. The machine learning community has made great strides", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "score": 1.0, + "content": "in this machine learning task, due to the invention of assorted deep learning representations and their", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "associated regularization terms (Krizhevsky et al., 2012; He et al., 2016). Many of these models take", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 574, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 588 + ], + "score": 1.0, + "content": "large amounts of fully labeled data for granted, and big data is indispensable for discovering accu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "rate representations (Hastie et al., 2009). To sustain this progress, and alleviate the need for more", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "labeled data, there is a growing interest into utilizing unlabeled data to augment the predictive power", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 607, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 505, + 621 + ], + "score": 1.0, + "content": "of classifiers (Stewart & Ermon, 2017; Bilenko et al., 2004). This section shows why semantic loss", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 619, + 232, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 232, + 631 + ], + "score": 1.0, + "content": "naturally qualifies for this task.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 656 + ], + "score": 1.0, + "content": "Illustrative Example To illustrate the benefit of semantic loss in the semi-supervised setting, we", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "begin our discussion with a small toy example. Consider a binary classification task as depicted", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "in Figure 2. Ignoring the unlabeled examples, a simple linear classifier learns to distinguish the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "two classes by separating the labeled examples in Figure 2a. However, the unlabeled examples", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "are also informative, as they must carry some properties that give them a particular label. This is", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "the crux of semantic loss: a model must confidently assign a consistent class even to unlabeled", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "data. Encouraging the model to do so results in a more accurate decision boundary, as illustrated in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 721, + 497, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 497, + 733 + ], + "score": 1.0, + "content": "Figure 2b. Next, we further explore this idea and apply it to real-world image classification tasks.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 150, + 89, + 452, + 183 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 150, + 89, + 452, + 183 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 150, + 89, + 452, + 183 + ], + "spans": [ + { + "bbox": [ + 150, + 89, + 452, + 183 + ], + "score": 0.686, + "type": "image", + "image_path": "5fcbfe708dc5ef9963d1119ec14ca3d17f5eace11a8e49df2a20fcaf583e6a6f.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 150, + 89, + 452, + 120.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 150, + 120.33333333333333, + 452, + 151.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 150, + 151.66666666666666, + 452, + 183.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 116, + 191, + 493, + 204 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 116, + 191, + 494, + 204 + ], + "spans": [ + { + "bbox": [ + 116, + 191, + 494, + 204 + ], + "score": 1.0, + "content": "Figure 2: Binary classification toy example: a linear classifier without and with semantic loss.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 107, + 226, + 237, + 237 + ], + "lines": [ + { + "bbox": [ + 105, + 225, + 239, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 239, + 239 + ], + "score": 1.0, + "content": "3.3 A GENERAL DEFINITION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 504, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "Lemma 3 falls short as a full definition of semantic loss for arbitrary sentences. One can define", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 258, + 461, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 230, + 271 + ], + "score": 1.0, + "content": "additional axioms to pin down", + "type": "text" + }, + { + "bbox": [ + 230, + 258, + 241, + 268 + ], + "score": 0.58, + "content": "\\mathrm { L } ^ { \\mathrm { s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 258, + 461, + 271 + ], + "score": 1.0, + "content": ". For example, the following axiom is highly desirable.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 106, + 247, + 505, + 271 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 502, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 503, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 279, + 286 + ], + "score": 1.0, + "content": "Axiom 6 (Differentiability). For any fixed", + "type": "text" + }, + { + "bbox": [ + 279, + 276, + 287, + 284 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 273, + 361, + 286 + ], + "score": 1.0, + "content": ", the semantic loss", + "type": "text" + }, + { + "bbox": [ + 362, + 274, + 396, + 286 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 273, + 503, + 286 + ], + "score": 1.0, + "content": "is monotone in each prob-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 285, + 276, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 276, + 296 + ], + "score": 1.0, + "content": "ability in p, continuous and differentiable.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 273, + 503, + 296 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 302, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "Appendix A makes the notion of semantic loss precise by stating one additional axiom. It is based", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 313, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 505, + 325 + ], + "score": 1.0, + "content": "on the observation that the state loss of Lemma 3 is proportionate to a log-probability. In particular,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 316, + 336 + ], + "score": 1.0, + "content": "it corresponds to the probability of obtaining state", + "type": "text" + }, + { + "bbox": [ + 316, + 326, + 325, + 334 + ], + "score": 0.51, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 324, + 469, + 336 + ], + "score": 1.0, + "content": "after independently sampling each", + "type": "text" + }, + { + "bbox": [ + 470, + 325, + 483, + 335 + ], + "score": 0.88, + "content": "X _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 335, + 488, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 152, + 348 + ], + "score": 1.0, + "content": "probability", + "type": "text" + }, + { + "bbox": [ + 153, + 336, + 162, + 347 + ], + "score": 0.83, + "content": "{ \\mathsf { p } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 335, + 488, + 348 + ], + "score": 1.0, + "content": ". We have now derived the semantic loss function from first principles as follows.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 104, + 302, + 506, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 350, + 504, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 350, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 246, + 363 + ], + "score": 1.0, + "content": "Definition 1 (Semantic Loss). Let", + "type": "text" + }, + { + "bbox": [ + 247, + 353, + 253, + 362 + ], + "score": 0.29, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 350, + 462, + 363 + ], + "score": 1.0, + "content": "be a vector of probabilities, one for each variable in", + "type": "text" + }, + { + "bbox": [ + 462, + 351, + 472, + 361 + ], + "score": 0.73, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 472, + 350, + 505, + 363 + ], + "score": 1.0, + "content": ", and let", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 361, + 358, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 114, + 372 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 361, + 191, + 375 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 191, + 362, + 201, + 372 + ], + "score": 0.34, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 361, + 315, + 375 + ], + "score": 1.0, + "content": ". The semantic loss between", + "type": "text" + }, + { + "bbox": [ + 315, + 364, + 322, + 372 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 361, + 340, + 375 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 340, + 364, + 347, + 373 + ], + "score": 0.7, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 361, + 358, + 375 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 350, + 505, + 375 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 379, + 411, + 408 + ], + "lines": [ + { + "bbox": [ + 199, + 379, + 411, + 408 + ], + "spans": [ + { + "bbox": [ + 199, + 379, + 411, + 408 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathfrak { p } ) \\propto - \\log \\sum _ { \\mathbf { x } \\in \\alpha } \\ \\prod _ { i : \\mathbf { x } | = X _ { i } } \\mathfrak { p } _ { i } \\prod _ { i : \\mathbf { x } | = \\ l - X _ { i } } ( 1 - \\mathfrak { p } _ { i } ) .", + "type": "interline_equation", + "image_path": "5cdaa907f91cf65ce0836950e29b48878daf757f6c8fdd7e1bf203317f92f496.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 379, + 411, + 393.5 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 199, + 393.5, + 411, + 408.0 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 415, + 505, + 437 + ], + "lines": [ + { + "bbox": [ + 106, + 413, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 505, + 428 + ], + "score": 1.0, + "content": "Theorem 4 (Uniqueness). The semantic loss function in Definition 1 satisfies Axioms 1–9 and is the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 425, + 339, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 339, + 438 + ], + "score": 1.0, + "content": "only function that does so, up to a multiplicative constant.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 413, + 505, + 438 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Intuitively, the semantic loss is proportionate to a negative logarithm of the probability of generating", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 104, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "a state that satisfies the constraint, when sampling values according to p. Hence, it is the self-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 465, + 493, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 493, + 477 + ], + "score": 1.0, + "content": "information (or “surprise”) of obtaining an assignment that satisfies the constraint (Jones, 1979).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 104, + 442, + 505, + 477 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 494, + 311, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 312, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 312, + 509 + ], + "score": 1.0, + "content": "4 SEMI-SUPERVISED CLASSIFICATION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 519, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "score": 1.0, + "content": "The most straightforward constraint that is ubiquitous in multi-class classification is mutual exclu-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "sion over one-hot-encoded outputs. That is, for a given example, exactly one class and therefore", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 505, + 555 + ], + "score": 1.0, + "content": "exactly one binary indicator must be true. The machine learning community has made great strides", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "score": 1.0, + "content": "in this machine learning task, due to the invention of assorted deep learning representations and their", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "associated regularization terms (Krizhevsky et al., 2012; He et al., 2016). Many of these models take", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 574, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 588 + ], + "score": 1.0, + "content": "large amounts of fully labeled data for granted, and big data is indispensable for discovering accu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "rate representations (Hastie et al., 2009). To sustain this progress, and alleviate the need for more", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "labeled data, there is a growing interest into utilizing unlabeled data to augment the predictive power", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 607, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 505, + 621 + ], + "score": 1.0, + "content": "of classifiers (Stewart & Ermon, 2017; Bilenko et al., 2004). This section shows why semantic loss", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 619, + 232, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 232, + 631 + ], + "score": 1.0, + "content": "naturally qualifies for this task.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 520, + 506, + 631 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 656 + ], + "score": 1.0, + "content": "Illustrative Example To illustrate the benefit of semantic loss in the semi-supervised setting, we", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "begin our discussion with a small toy example. Consider a binary classification task as depicted", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "in Figure 2. Ignoring the unlabeled examples, a simple linear classifier learns to distinguish the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "two classes by separating the labeled examples in Figure 2a. However, the unlabeled examples", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "are also informative, as they must carry some properties that give them a particular label. This is", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "the crux of semantic loss: a model must confidently assign a consistent class even to unlabeled", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "data. Encouraging the model to do so results in a more accurate decision boundary, as illustrated in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 721, + 497, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 497, + 733 + ], + "score": 1.0, + "content": "Figure 2b. Next, we further explore this idea and apply it to real-world image classification tasks.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 643, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 111, + 100, + 501, + 195 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 80, + 500, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 78, + 501, + 93 + ], + "spans": [ + { + "bbox": [ + 109, + 78, + 459, + 93 + ], + "score": 1.0, + "content": "Table 1: MNIST. Previously reported test accuracies followed by semantic loss results", + "type": "text" + }, + { + "bbox": [ + 460, + 81, + 469, + 91 + ], + "score": 0.53, + "content": "\\pm", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 78, + 501, + 93 + ], + "score": 1.0, + "content": "stddev)", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 111, + 100, + 501, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 100, + 501, + 195 + ], + "spans": [ + { + "bbox": [ + 111, + 100, + 501, + 195 + ], + "score": 0.981, + "html": "
Accuracy % with # of used labels1001000ALL
AtlasRBF (Pitelis et al., 2014) Deep Generative (Kingma et al., 2014) Virtual Adversarial (Miyato et al., 2016) Ladder Net (Rasmus et al., 2015)91.9 (± 0.95) 96.67(± 0.14) 97.67 98.94(±0.37)96.32 (± 0.12) 97.60(± 0.02) 98.64 99.16 (±0.08)98.69 99.04 99.36 99.43 (± 0.02)
Baseline: MLP, Gaussian Noise Baseline: Self-Training MLP with Semantic Loss (our)78.46 (±1.94) 72.55 (±4.21) 98.38 (±0.51)94.26 (±0.31) 87.43 (±3.07) 98.78 (±0.17)99.34(±0.08) 99.34 (±0.08) 99.36 (±0.02)
", + "type": "table", + "image_path": "382d2a4abe15b2139dd29370c328c0091c8c8c4c4c01dfa3666c36f7e07b0f84.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 111, + 100, + 501, + 131.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 131.66666666666666, + 501, + 163.33333333333331 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 111, + 163.33333333333331, + 501, + 194.99999999999997 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "title", + "bbox": [ + 107, + 212, + 171, + 223 + ], + "lines": [ + { + "bbox": [ + 105, + 210, + 172, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 172, + 225 + ], + "score": 1.0, + "content": "4.1 METHOD", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 233, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 233, + 505, + 245 + ], + "score": 1.0, + "content": "Our proposed method intends to be generally applicable and compatible with any feedforward neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "network. The semantic loss is simply another regularization term that can directly be plugged into", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 254, + 481, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 350, + 267 + ], + "score": 1.0, + "content": "an existing loss function. More specifically, for some weight", + "type": "text" + }, + { + "bbox": [ + 350, + 257, + 358, + 264 + ], + "score": 0.75, + "content": "w", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 254, + 481, + 267 + ], + "score": 1.0, + "content": ", the new overall loss becomes", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 319 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 299 + ], + "score": 1.0, + "content": "When the constraint over the output space is simple (for example, there is a small number of solu-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 297, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 129, + 309 + ], + "score": 1.0, + "content": "tions", + "type": "text" + }, + { + "bbox": [ + 129, + 297, + 162, + 308 + ], + "score": 0.89, + "content": "{ \\textbf { x } } | = \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 297, + 505, + 309 + ], + "score": 1.0, + "content": "), the semantic loss can be directly computed from Definition 1. Concretely, for the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 308, + 430, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 228, + 320 + ], + "score": 1.0, + "content": "exactly-one constraint used in", + "type": "text" + }, + { + "bbox": [ + 228, + 309, + 235, + 317 + ], + "score": 0.77, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 308, + 430, + 320 + ], + "score": 1.0, + "content": "-class classification, the semantic loss reduces to", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 322, + 410, + 358 + ], + "lines": [ + { + "bbox": [ + 199, + 322, + 410, + 358 + ], + "spans": [ + { + "bbox": [ + 199, + 322, + 410, + 358 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\mathrm { e x a c t l y - o n e } , \\mathsf { p } ) \\propto - \\log \\sum _ { i = 0 } ^ { n - 1 } \\mathsf { p } _ { i } \\prod _ { j = 0 , j \\neq i } ^ { n - 1 } ( 1 - \\mathsf { p } _ { j } ) ,", + "type": "interline_equation", + "image_path": "353f7d32bbc0b6553e939f45db8e9abcc0faed8d6e0a32bd8bee3c093b1cac7f.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 322, + 410, + 340.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 199, + 340.0, + 410, + 358.0 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 172, + 373 + ], + "score": 1.0, + "content": "where he values", + "type": "text" + }, + { + "bbox": [ + 172, + 362, + 182, + 372 + ], + "score": 0.86, + "content": "{ \\mathsf { p } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 360, + 304, + 373 + ], + "score": 1.0, + "content": "denote the probability of class", + "type": "text" + }, + { + "bbox": [ + 304, + 361, + 309, + 370 + ], + "score": 0.77, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "as predicted by the neural net. The semantic loss", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 371, + 489, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 489, + 384 + ], + "score": 1.0, + "content": "for the exactly-one constraint is efficient and causes no noticeable overhead in our experiments.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 105, + 388, + 504, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 245, + 401 + ], + "score": 1.0, + "content": "In general, for arbitrary constraints", + "type": "text" + }, + { + "bbox": [ + 246, + 390, + 253, + 398 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 388, + 505, + 401 + ], + "score": 1.0, + "content": ", the semantic loss is not efficient to compute using Definition 1,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 399, + 499, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 499, + 411 + ], + "score": 1.0, + "content": "and more advanced automated reasoning is required. Section 5 discusses this issue in more detail.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 108, + 423, + 257, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 258, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 258, + 436 + ], + "score": 1.0, + "content": "4.2 EXPERIMENTAL EVALUATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "In this section, we evaluate semantic loss in the semi-supervised setting by comparing it with several", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 456, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 468 + ], + "score": 1.0, + "content": "competitive models. As most semi-supervised learners build on a supervised learner, changing the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "score": 1.0, + "content": "underlying model significantly affects the semi-supervised learner’s performance. For comparison,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "we add semantic loss to the same base models used in ladder nets (Rasmus et al., 2015), which", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 487, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 502 + ], + "score": 1.0, + "content": "currently achieve state-of-the-art results on semi-supervised MNIST and CIFAR-10 (Krizhevsky", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "& Hinton, 2009). Specifically, the MNIST base model is a fully-connected multilayer perceptron", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 510, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 504, + 523 + ], + "score": 1.0, + "content": "(MLP), with layers of size 784-1000-500-250-250-250-10. On CIFAR-10, it is a 10-layer convolu-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "tional neural network (CNN) with 3-by-3 padded filters. After every 3 layers, features are subject", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "to a 2-by-2 max-pool layer with strides of 2. Furthermore, we use ReLu (Nair & Hinton, 2010),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "batch normalization (Ioffe & Szegedy, 2015), and Adam optimization (Kingma & Ba, 2015) with", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "a learning rate of 0.002. We refer to Appendix B and C for a specification of the CNN model and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 564, + 300, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 300, + 578 + ], + "score": 1.0, + "content": "additional details about hyper-parameter tuning.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 593 + ], + "score": 1.0, + "content": "For all semi-supervised experiments, we use the standard 10,000 held-out test examples provided in", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "the original datasets and randomly pick 10,000 from the standard 60,000 training examples (50,000", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 603, + 504, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 306, + 616 + ], + "score": 1.0, + "content": "for CIFAR-10) as validation set. For values of", + "type": "text" + }, + { + "bbox": [ + 306, + 604, + 317, + 614 + ], + "score": 0.79, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 603, + 493, + 616 + ], + "score": 1.0, + "content": "that depend on the experiment, we retain", + "type": "text" + }, + { + "bbox": [ + 493, + 604, + 504, + 614 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "score": 1.0, + "content": "randomly chosen labeled examples from the training set, and remove labels from the rest. We", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 625, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 505, + 639 + ], + "score": 1.0, + "content": "balance classes in the labeled samples to ensure no particular class is over-represented. Images are", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 636, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 104, + 636, + 506, + 649 + ], + "score": 1.0, + "content": "preprocessed for standardization and Gaussian noise (standard deviation 0.3) is added to every pixel.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 504, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "MNIST The permutation invariant MNIST classification task is commonly used as a test-bed for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "general semi-supervised learning algorithms. This setting does not use any prior information about", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "the spatial arrangement of the input pixels. Therefore, it excludes many data augmentation tech-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 693, + 478, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 478, + 705 + ], + "score": 1.0, + "content": "niques that involve geometric distortion of images, as well as convolutional neural networks.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "When evaluating on MNIST, we run experiments for 10 epochs, with a batch size of 10 labeled and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "10 unlabeled examples. Experiments are repeated 10 times with different random seeds. Table 1", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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": "table", + "bbox": [ + 111, + 100, + 501, + 195 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 80, + 500, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 78, + 501, + 93 + ], + "spans": [ + { + "bbox": [ + 109, + 78, + 459, + 93 + ], + "score": 1.0, + "content": "Table 1: MNIST. Previously reported test accuracies followed by semantic loss results", + "type": "text" + }, + { + "bbox": [ + 460, + 81, + 469, + 91 + ], + "score": 0.53, + "content": "\\pm", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 78, + 501, + 93 + ], + "score": 1.0, + "content": "stddev)", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 111, + 100, + 501, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 100, + 501, + 195 + ], + "spans": [ + { + "bbox": [ + 111, + 100, + 501, + 195 + ], + "score": 0.981, + "html": "
Accuracy % with # of used labels1001000ALL
AtlasRBF (Pitelis et al., 2014) Deep Generative (Kingma et al., 2014) Virtual Adversarial (Miyato et al., 2016) Ladder Net (Rasmus et al., 2015)91.9 (± 0.95) 96.67(± 0.14) 97.67 98.94(±0.37)96.32 (± 0.12) 97.60(± 0.02) 98.64 99.16 (±0.08)98.69 99.04 99.36 99.43 (± 0.02)
Baseline: MLP, Gaussian Noise Baseline: Self-Training MLP with Semantic Loss (our)78.46 (±1.94) 72.55 (±4.21) 98.38 (±0.51)94.26 (±0.31) 87.43 (±3.07) 98.78 (±0.17)99.34(±0.08) 99.34 (±0.08) 99.36 (±0.02)
", + "type": "table", + "image_path": "382d2a4abe15b2139dd29370c328c0091c8c8c4c4c01dfa3666c36f7e07b0f84.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 111, + 100, + 501, + 131.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 131.66666666666666, + 501, + 163.33333333333331 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 111, + 163.33333333333331, + 501, + 194.99999999999997 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "title", + "bbox": [ + 107, + 212, + 171, + 223 + ], + "lines": [ + { + "bbox": [ + 105, + 210, + 172, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 172, + 225 + ], + "score": 1.0, + "content": "4.1 METHOD", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 266 + ], + "lines": [ + { + "bbox": [ + 106, + 233, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 233, + 505, + 245 + ], + "score": 1.0, + "content": "Our proposed method intends to be generally applicable and compatible with any feedforward neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "network. The semantic loss is simply another regularization term that can directly be plugged into", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 254, + 481, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 350, + 267 + ], + "score": 1.0, + "content": "an existing loss function. More specifically, for some weight", + "type": "text" + }, + { + "bbox": [ + 350, + 257, + 358, + 264 + ], + "score": 0.75, + "content": "w", + "type": "inline_equation" + }, + { + "bbox": [ + 359, + 254, + 481, + 267 + ], + "score": 1.0, + "content": ", the new overall loss becomes", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 233, + 505, + 267 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 319 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 299 + ], + "score": 1.0, + "content": "When the constraint over the output space is simple (for example, there is a small number of solu-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 297, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 129, + 309 + ], + "score": 1.0, + "content": "tions", + "type": "text" + }, + { + "bbox": [ + 129, + 297, + 162, + 308 + ], + "score": 0.89, + "content": "{ \\textbf { x } } | = \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 297, + 505, + 309 + ], + "score": 1.0, + "content": "), the semantic loss can be directly computed from Definition 1. Concretely, for the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 308, + 430, + 320 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 228, + 320 + ], + "score": 1.0, + "content": "exactly-one constraint used in", + "type": "text" + }, + { + "bbox": [ + 228, + 309, + 235, + 317 + ], + "score": 0.77, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 308, + 430, + 320 + ], + "score": 1.0, + "content": "-class classification, the semantic loss reduces to", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 285, + 505, + 320 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 199, + 322, + 410, + 358 + ], + "lines": [ + { + "bbox": [ + 199, + 322, + 410, + 358 + ], + "spans": [ + { + "bbox": [ + 199, + 322, + 410, + 358 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\mathrm { e x a c t l y - o n e } , \\mathsf { p } ) \\propto - \\log \\sum _ { i = 0 } ^ { n - 1 } \\mathsf { p } _ { i } \\prod _ { j = 0 , j \\neq i } ^ { n - 1 } ( 1 - \\mathsf { p } _ { j } ) ,", + "type": "interline_equation", + "image_path": "353f7d32bbc0b6553e939f45db8e9abcc0faed8d6e0a32bd8bee3c093b1cac7f.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 322, + 410, + 340.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 199, + 340.0, + 410, + 358.0 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 360, + 172, + 373 + ], + "score": 1.0, + "content": "where he values", + "type": "text" + }, + { + "bbox": [ + 172, + 362, + 182, + 372 + ], + "score": 0.86, + "content": "{ \\mathsf { p } } _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 360, + 304, + 373 + ], + "score": 1.0, + "content": "denote the probability of class", + "type": "text" + }, + { + "bbox": [ + 304, + 361, + 309, + 370 + ], + "score": 0.77, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 360, + 505, + 373 + ], + "score": 1.0, + "content": "as predicted by the neural net. The semantic loss", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 371, + 489, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 489, + 384 + ], + "score": 1.0, + "content": "for the exactly-one constraint is efficient and causes no noticeable overhead in our experiments.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 360, + 505, + 384 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 388, + 504, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 245, + 401 + ], + "score": 1.0, + "content": "In general, for arbitrary constraints", + "type": "text" + }, + { + "bbox": [ + 246, + 390, + 253, + 398 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 388, + 505, + 401 + ], + "score": 1.0, + "content": ", the semantic loss is not efficient to compute using Definition 1,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 399, + 499, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 499, + 411 + ], + "score": 1.0, + "content": "and more advanced automated reasoning is required. Section 5 discusses this issue in more detail.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 388, + 505, + 411 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 423, + 257, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 258, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 258, + 436 + ], + "score": 1.0, + "content": "4.2 EXPERIMENTAL EVALUATION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "In this section, we evaluate semantic loss in the semi-supervised setting by comparing it with several", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 456, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 468 + ], + "score": 1.0, + "content": "competitive models. As most semi-supervised learners build on a supervised learner, changing the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "score": 1.0, + "content": "underlying model significantly affects the semi-supervised learner’s performance. For comparison,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "we add semantic loss to the same base models used in ladder nets (Rasmus et al., 2015), which", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 487, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 502 + ], + "score": 1.0, + "content": "currently achieve state-of-the-art results on semi-supervised MNIST and CIFAR-10 (Krizhevsky", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 498, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 505, + 512 + ], + "score": 1.0, + "content": "& Hinton, 2009). Specifically, the MNIST base model is a fully-connected multilayer perceptron", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 510, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 504, + 523 + ], + "score": 1.0, + "content": "(MLP), with layers of size 784-1000-500-250-250-250-10. On CIFAR-10, it is a 10-layer convolu-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "tional neural network (CNN) with 3-by-3 padded filters. After every 3 layers, features are subject", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "to a 2-by-2 max-pool layer with strides of 2. Furthermore, we use ReLu (Nair & Hinton, 2010),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 555 + ], + "score": 1.0, + "content": "batch normalization (Ioffe & Szegedy, 2015), and Adam optimization (Kingma & Ba, 2015) with", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 104, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "a learning rate of 0.002. We refer to Appendix B and C for a specification of the CNN model and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 564, + 300, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 300, + 578 + ], + "score": 1.0, + "content": "additional details about hyper-parameter tuning.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 444, + 506, + 578 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 593 + ], + "score": 1.0, + "content": "For all semi-supervised experiments, we use the standard 10,000 held-out test examples provided in", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "the original datasets and randomly pick 10,000 from the standard 60,000 training examples (50,000", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 603, + 504, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 306, + 616 + ], + "score": 1.0, + "content": "for CIFAR-10) as validation set. For values of", + "type": "text" + }, + { + "bbox": [ + 306, + 604, + 317, + 614 + ], + "score": 0.79, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 603, + 493, + 616 + ], + "score": 1.0, + "content": "that depend on the experiment, we retain", + "type": "text" + }, + { + "bbox": [ + 493, + 604, + 504, + 614 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 627 + ], + "score": 1.0, + "content": "randomly chosen labeled examples from the training set, and remove labels from the rest. We", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 625, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 505, + 639 + ], + "score": 1.0, + "content": "balance classes in the labeled samples to ensure no particular class is over-represented. Images are", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 636, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 104, + 636, + 506, + 649 + ], + "score": 1.0, + "content": "preprocessed for standardization and Gaussian noise (standard deviation 0.3) is added to every pixel.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5, + "bbox_fs": [ + 104, + 582, + 506, + 649 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 659, + 504, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "MNIST The permutation invariant MNIST classification task is commonly used as a test-bed for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "general semi-supervised learning algorithms. This setting does not use any prior information about", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "the spatial arrangement of the input pixels. Therefore, it excludes many data augmentation tech-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 693, + 478, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 478, + 705 + ], + "score": 1.0, + "content": "niques that involve geometric distortion of images, as well as convolutional neural networks.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 660, + 506, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "When evaluating on MNIST, we run experiments for 10 epochs, with a batch size of 10 labeled and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "10 unlabeled examples. Experiments are repeated 10 times with different random seeds. Table 1", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "compares semantic loss to two baselines and state-of-the-art results from the literature. The first", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "baseline is a purely supervised MLP, which makes no use of unlabeled data. The second is the", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 281, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 505, + 296 + ], + "score": 1.0, + "content": "classic self-training method for semi-supervised learning, which operates as follows. After every", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 292, + 504, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 484, + 306 + ], + "score": 1.0, + "content": "1000 iterations, the unlabeled examples that are predicted by the MLP to have more than", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 484, + 293, + 504, + 304 + ], + "score": 0.87, + "content": "9 5 \\%", + "type": "inline_equation", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 304, + 488, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 488, + 318 + ], + "score": 1.0, + "content": "probability of belonging to a single class, are assigned a psuedo-label and become labeled data.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 100, + 502, + 150 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 109, + 80, + 499, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 79, + 500, + 93 + ], + "spans": [ + { + "bbox": [ + 111, + 79, + 500, + 93 + ], + "score": 1.0, + "content": "Table 2: FASHION. Test accuracy comparison between MLP with semantic loss and ladder nets.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 109, + 100, + 502, + 150 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 100, + 502, + 150 + ], + "spans": [ + { + "bbox": [ + 109, + 100, + 502, + 150 + ], + "score": 0.968, + "html": "
Accuracy % with # of used labels1005001000ALL
Ladder Net (Rasmus et al., 2015)81.46(±0.64)85.18 (±0.27)86.48 (± 0.15)90.46
Baseline:MLP,GaussianNoise69.45 (±2.03)78.12 (±1.41)80.94(±0.84)89.87
MLP with Semantic Loss (our)86.74 (±0.71)89.49 (±0.24)89.67 (±0.09)89.81
", + "type": "table", + "image_path": "ff89704f644f3e6593c3c8d83828a360887e7d0e6cd80810cac0c10c4a2f074a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 109, + 100, + 502, + 116.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 116.66666666666667, + 502, + 133.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 109, + 133.33333333333334, + 502, + 150.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 169, + 180, + 441, + 240 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 113, + 159, + 493, + 172 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 118, + 159, + 493, + 173 + ], + "spans": [ + { + "bbox": [ + 118, + 159, + 493, + 173 + ], + "score": 1.0, + "content": "Table 3: CIFAR. Test accuracy comparison between CNN with semantic loss and ladder nets.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 169, + 180, + 441, + 240 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 169, + 180, + 441, + 240 + ], + "spans": [ + { + "bbox": [ + 169, + 180, + 441, + 240 + ], + "score": 0.954, + "html": "
Accuracy % with # of used labels4000ALL
CNNBaselineinLadderNetLadder Net (Rasmus et al., 2015)Baseline: CNN,Whitening, CroppingCNN with Semantic Loss (our)76.67 (± 0.61)79.60 (±0.47)90.73
77.1381.7990.9690.92
", + "type": "table", + "image_path": "b7d62a35b32a503a67f361db1b27aa8cf0b87fac738baa883106d21dc7e09056.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 169, + 180, + 441, + 200.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 169, + 200.0, + 441, + 220.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 169, + 220.0, + 441, + 240.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 107, + 260, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "compares semantic loss to two baselines and state-of-the-art results from the literature. The first", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "baseline is a purely supervised MLP, which makes no use of unlabeled data. The second is the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 281, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 505, + 296 + ], + "score": 1.0, + "content": "classic self-training method for semi-supervised learning, which operates as follows. After every", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 292, + 504, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 484, + 306 + ], + "score": 1.0, + "content": "1000 iterations, the unlabeled examples that are predicted by the MLP to have more than", + "type": "text" + }, + { + "bbox": [ + 484, + 293, + 504, + 304 + ], + "score": 0.87, + "content": "9 5 \\%", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 304, + 488, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 488, + 318 + ], + "score": 1.0, + "content": "probability of belonging to a single class, are assigned a psuedo-label and become labeled data.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 321, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 255, + 334 + ], + "score": 1.0, + "content": "When given 100 labeled examples (", + "type": "text" + }, + { + "bbox": [ + 255, + 321, + 299, + 332 + ], + "score": 0.85, + "content": "N = 1 0 0 \\mathrm { \\ : }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 321, + 466, + 334 + ], + "score": 1.0, + "content": "), MLP with semantic loss gains around", + "type": "text" + }, + { + "bbox": [ + 467, + 321, + 487, + 332 + ], + "score": 0.87, + "content": "2 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "im-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 332, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 426, + 345 + ], + "score": 1.0, + "content": "provement over the purely supervised baseline. The improvement is even larger", + "type": "text" + }, + { + "bbox": [ + 426, + 333, + 451, + 344 + ], + "score": 0.83, + "content": "( 2 5 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 332, + 505, + 345 + ], + "score": 1.0, + "content": "compared to", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 342, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 342, + 505, + 357 + ], + "score": 1.0, + "content": "self-training. Considering the only change is an additional loss term, this result is very encouraging.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 353, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 441, + 368 + ], + "score": 1.0, + "content": "Compared to the state of the art, ladder nets slightly outperform semantic loss by", + "type": "text" + }, + { + "bbox": [ + 441, + 354, + 464, + 365 + ], + "score": 0.87, + "content": "0 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 353, + 505, + 368 + ], + "score": 1.0, + "content": "accuracy.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "This difference may be an artifact of the excessive tuning of architectures, hyper-parameters and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "learning rates that the MNIST dataset has been subject to. In the coming experiments, we extend", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 388, + 495, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 495, + 400 + ], + "score": 1.0, + "content": "our work to more challenging datasets, in order to provide a clearer comparison with ladder nets.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 504, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 504, + 415 + ], + "score": 1.0, + "content": "First, we want to share a few more thoughts on how semantic loss works. A classical softmax", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 415, + 504, + 427 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 504, + 427 + ], + "score": 1.0, + "content": "layer interprets its output as representing a categorical distribution. Hence, by normalizing its out-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 426, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 438 + ], + "score": 1.0, + "content": "puts, softmax enforces the same mutual exclusion constraint enforced in our semantic loss function.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 436, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 450 + ], + "score": 1.0, + "content": "However, there does not exist a natural way to extend softmax loss to unlabeled samples. In con-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 446, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 104, + 446, + 505, + 462 + ], + "score": 1.0, + "content": "trast, semantic loss does provide a learning signal on unlabeled samples, by forcing the underlying", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "classifier to make an decision and construct a confident hypothesis for all data. However, for the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 197, + 483 + ], + "score": 1.0, + "content": "fully supervised case", + "type": "text" + }, + { + "bbox": [ + 197, + 470, + 234, + 480 + ], + "score": 0.84, + "content": "N = \\mathrm { a l l }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "), the semantic loss does not significantly affect accuracy. Because", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 479, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 505, + 495 + ], + "score": 1.0, + "content": "the MLP has enough capacity to almost perfectly fit the training data, where the constraint is always", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 491, + 489, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 489, + 505 + ], + "score": 1.0, + "content": "satisfied, the semantic loss is almost always zero. This is a direct consequence of Proposition 2.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 515, + 505, + 582 + ], + "lines": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "FASHION The FASHION (Xiao et al., 2017) dataset consists of Zalando’s article images, aiming", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "to serve as a more challenging drop-in replacement for MNIST. Arguably, it has not been overused", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "and requires more advanced techniques to achieve good performance. As in the previous experi-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 548, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 561 + ], + "score": 1.0, + "content": "ment, we run our method for 10 epochs, whereas ladder nets need 100 epochs to converge. Again,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "experiments are repeated 10 times and Table 2 reports the classification accuracy and its standard", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 570, + 405, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 191, + 582 + ], + "score": 1.0, + "content": "deviation (except for", + "type": "text" + }, + { + "bbox": [ + 192, + 570, + 213, + 580 + ], + "score": 0.81, + "content": "N =", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 571, + 405, + 582 + ], + "score": 1.0, + "content": "all where it is close to 0 and omitted for space).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 391, + 599 + ], + "score": 1.0, + "content": "Experiments show that utilizing semantic loss results in a very large", + "type": "text" + }, + { + "bbox": [ + 391, + 587, + 411, + 598 + ], + "score": 0.87, + "content": "1 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "improvement over the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 611 + ], + "score": 1.0, + "content": "baseline when only 100 labels are provided. Moreover, our method compares favorably to ladder", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 621 + ], + "score": 1.0, + "content": "nets, except when the setting degrades to be fully supervised. Note that our method already nearly", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 398, + 633 + ], + "score": 1.0, + "content": "reaches its maximum accuracy with 500 labeled examples, which is only", + "type": "text" + }, + { + "bbox": [ + 398, + 620, + 413, + 631 + ], + "score": 0.87, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "of the training dataset.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 106, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "CIFAR-10 To show the general applicability of semantic loss, we evaluate it on CIFAR-10. This", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "dataset consisting of 32-by-32 RGB images in 10 classes. A simple MLP would not have enough", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "representation power to capture the huge variance across objects within the same class. To cope with", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "this spike in difficulty, we switch our underlying model to a 10-layer CNN as described earlier. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 687, + 504, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 504, + 700 + ], + "score": 1.0, + "content": "use a batch size of 100 samples of which half are unlabeled. Experiments are run for 100 epochs.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "However, due to our limited computational resources, we report on a single trial. Note that we", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "make slight modifications to the underlying model used in ladder nets to reproduce similar baseline", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 438, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 438, + 734 + ], + "score": 1.0, + "content": "performance. Please refer to Appendix B for the details of this experimental setup.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 100, + 502, + 150 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 109, + 80, + 499, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 79, + 500, + 93 + ], + "spans": [ + { + "bbox": [ + 111, + 79, + 500, + 93 + ], + "score": 1.0, + "content": "Table 2: FASHION. Test accuracy comparison between MLP with semantic loss and ladder nets.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 109, + 100, + 502, + 150 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 100, + 502, + 150 + ], + "spans": [ + { + "bbox": [ + 109, + 100, + 502, + 150 + ], + "score": 0.968, + "html": "
Accuracy % with # of used labels1005001000ALL
Ladder Net (Rasmus et al., 2015)81.46(±0.64)85.18 (±0.27)86.48 (± 0.15)90.46
Baseline:MLP,GaussianNoise69.45 (±2.03)78.12 (±1.41)80.94(±0.84)89.87
MLP with Semantic Loss (our)86.74 (±0.71)89.49 (±0.24)89.67 (±0.09)89.81
", + "type": "table", + "image_path": "ff89704f644f3e6593c3c8d83828a360887e7d0e6cd80810cac0c10c4a2f074a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 109, + 100, + 502, + 116.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 116.66666666666667, + 502, + 133.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 109, + 133.33333333333334, + 502, + 150.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 169, + 180, + 441, + 240 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 113, + 159, + 493, + 172 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 118, + 159, + 493, + 173 + ], + "spans": [ + { + "bbox": [ + 118, + 159, + 493, + 173 + ], + "score": 1.0, + "content": "Table 3: CIFAR. Test accuracy comparison between CNN with semantic loss and ladder nets.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 169, + 180, + 441, + 240 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 169, + 180, + 441, + 240 + ], + "spans": [ + { + "bbox": [ + 169, + 180, + 441, + 240 + ], + "score": 0.954, + "html": "
Accuracy % with # of used labels4000ALL
CNNBaselineinLadderNetLadder Net (Rasmus et al., 2015)Baseline: CNN,Whitening, CroppingCNN with Semantic Loss (our)76.67 (± 0.61)79.60 (±0.47)90.73
77.1381.7990.9690.92
", + "type": "table", + "image_path": "b7d62a35b32a503a67f361db1b27aa8cf0b87fac738baa883106d21dc7e09056.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 169, + 180, + 441, + 200.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 169, + 200.0, + 441, + 220.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 169, + 220.0, + 441, + 240.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 107, + 260, + 505, + 316 + ], + "lines": [], + "index": 10, + "bbox_fs": [ + 105, + 261, + 505, + 318 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 321, + 505, + 398 + ], + "lines": [ + { + "bbox": [ + 106, + 321, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 321, + 255, + 334 + ], + "score": 1.0, + "content": "When given 100 labeled examples (", + "type": "text" + }, + { + "bbox": [ + 255, + 321, + 299, + 332 + ], + "score": 0.85, + "content": "N = 1 0 0 \\mathrm { \\ : }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 321, + 466, + 334 + ], + "score": 1.0, + "content": "), MLP with semantic loss gains around", + "type": "text" + }, + { + "bbox": [ + 467, + 321, + 487, + 332 + ], + "score": 0.87, + "content": "2 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 321, + 505, + 334 + ], + "score": 1.0, + "content": "im-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 332, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 426, + 345 + ], + "score": 1.0, + "content": "provement over the purely supervised baseline. The improvement is even larger", + "type": "text" + }, + { + "bbox": [ + 426, + 333, + 451, + 344 + ], + "score": 0.83, + "content": "( 2 5 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 332, + 505, + 345 + ], + "score": 1.0, + "content": "compared to", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 342, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 342, + 505, + 357 + ], + "score": 1.0, + "content": "self-training. Considering the only change is an additional loss term, this result is very encouraging.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 353, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 441, + 368 + ], + "score": 1.0, + "content": "Compared to the state of the art, ladder nets slightly outperform semantic loss by", + "type": "text" + }, + { + "bbox": [ + 441, + 354, + 464, + 365 + ], + "score": 0.87, + "content": "0 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 353, + 505, + 368 + ], + "score": 1.0, + "content": "accuracy.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "This difference may be an artifact of the excessive tuning of architectures, hyper-parameters and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "learning rates that the MNIST dataset has been subject to. In the coming experiments, we extend", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 388, + 495, + 400 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 495, + 400 + ], + "score": 1.0, + "content": "our work to more challenging datasets, in order to provide a clearer comparison with ladder nets.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16, + "bbox_fs": [ + 104, + 321, + 506, + 400 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 504, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 504, + 415 + ], + "score": 1.0, + "content": "First, we want to share a few more thoughts on how semantic loss works. A classical softmax", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 415, + 504, + 427 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 504, + 427 + ], + "score": 1.0, + "content": "layer interprets its output as representing a categorical distribution. Hence, by normalizing its out-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 426, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 438 + ], + "score": 1.0, + "content": "puts, softmax enforces the same mutual exclusion constraint enforced in our semantic loss function.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 436, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 450 + ], + "score": 1.0, + "content": "However, there does not exist a natural way to extend softmax loss to unlabeled samples. In con-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 446, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 104, + 446, + 505, + 462 + ], + "score": 1.0, + "content": "trast, semantic loss does provide a learning signal on unlabeled samples, by forcing the underlying", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "classifier to make an decision and construct a confident hypothesis for all data. However, for the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 197, + 483 + ], + "score": 1.0, + "content": "fully supervised case", + "type": "text" + }, + { + "bbox": [ + 197, + 470, + 234, + 480 + ], + "score": 0.84, + "content": "N = \\mathrm { a l l }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "), the semantic loss does not significantly affect accuracy. Because", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 479, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 505, + 495 + ], + "score": 1.0, + "content": "the MLP has enough capacity to almost perfectly fit the training data, where the constraint is always", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 491, + 489, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 489, + 505 + ], + "score": 1.0, + "content": "satisfied, the semantic loss is almost always zero. This is a direct consequence of Proposition 2.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24, + "bbox_fs": [ + 104, + 405, + 506, + 505 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 515, + 505, + 582 + ], + "lines": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "FASHION The FASHION (Xiao et al., 2017) dataset consists of Zalando’s article images, aiming", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "to serve as a more challenging drop-in replacement for MNIST. Arguably, it has not been overused", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "and requires more advanced techniques to achieve good performance. As in the previous experi-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 548, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 561 + ], + "score": 1.0, + "content": "ment, we run our method for 10 epochs, whereas ladder nets need 100 epochs to converge. Again,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "experiments are repeated 10 times and Table 2 reports the classification accuracy and its standard", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 570, + 405, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 191, + 582 + ], + "score": 1.0, + "content": "deviation (except for", + "type": "text" + }, + { + "bbox": [ + 192, + 570, + 213, + 580 + ], + "score": 0.81, + "content": "N =", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 571, + 405, + 582 + ], + "score": 1.0, + "content": "all where it is close to 0 and omitted for space).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 514, + 505, + 582 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 391, + 599 + ], + "score": 1.0, + "content": "Experiments show that utilizing semantic loss results in a very large", + "type": "text" + }, + { + "bbox": [ + 391, + 587, + 411, + 598 + ], + "score": 0.87, + "content": "1 7 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "improvement over the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 611 + ], + "score": 1.0, + "content": "baseline when only 100 labels are provided. Moreover, our method compares favorably to ladder", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 621 + ], + "score": 1.0, + "content": "nets, except when the setting degrades to be fully supervised. Note that our method already nearly", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 398, + 633 + ], + "score": 1.0, + "content": "reaches its maximum accuracy with 500 labeled examples, which is only", + "type": "text" + }, + { + "bbox": [ + 398, + 620, + 413, + 631 + ], + "score": 0.87, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "of the training dataset.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 587, + 506, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "CIFAR-10 To show the general applicability of semantic loss, we evaluate it on CIFAR-10. This", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "dataset consisting of 32-by-32 RGB images in 10 classes. A simple MLP would not have enough", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "representation power to capture the huge variance across objects within the same class. To cope with", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "this spike in difficulty, we switch our underlying model to a 10-layer CNN as described earlier. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 687, + 504, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 504, + 700 + ], + "score": 1.0, + "content": "use a batch size of 100 samples of which half are unlabeled. Experiments are run for 100 epochs.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "However, due to our limited computational resources, we report on a single trial. Note that we", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "make slight modifications to the underlying model used in ladder nets to reproduce similar baseline", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 438, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 438, + 734 + ], + "score": 1.0, + "content": "performance. Please refer to Appendix B for the details of this experimental setup.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 643, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 127 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "As shown in Table 3, our method compares favorably to ladder nets. However, due to the slight dif-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "ference in performance between the supervised base models, a direct comparison would be method-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "ologically flawed. Instead, we compare the net improvements over baselines. In terms of this mea-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 400, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 241, + 127 + ], + "score": 1.0, + "content": "sure, our method scores a gain of", + "type": "text" + }, + { + "bbox": [ + 241, + 115, + 268, + 126 + ], + "score": 0.88, + "content": "4 . { \\bar { 6 } } 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 116, + 370, + 127 + ], + "score": 1.0, + "content": "whereas ladder nets gain", + "type": "text" + }, + { + "bbox": [ + 370, + 115, + 397, + 126 + ], + "score": 0.88, + "content": "2 . 9 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 116, + 400, + 127 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 108, + 140, + 185, + 151 + ], + "lines": [ + { + "bbox": [ + 105, + 138, + 187, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 187, + 154 + ], + "score": 1.0, + "content": "4.3 DISCUSSION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 160, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Overall, the experiments so far have demonstrated the competitiveness and general applicability", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "of our proposed method on semi-supervised learning tasks. It surpassed the previous state of the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 182, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 506, + 196 + ], + "score": 1.0, + "content": "art (i.e. ladder nets ) on FASHION and CIFAR-10, while being close on MNIST. Considering the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "simplicity of our method, such results are encouraging. Indeed, a key advantage of semantic loss is", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "that it only requires a simple additional loss term. Without changing the network architecture itself,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 216, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 229 + ], + "score": 1.0, + "content": "we incur almost no computational overhead. Conversely, this property makes our method sensitive to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "the underlying model’s performance. Without the underlying predictive power of a strong supervised", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "learning model, we do not expect to see the same benefits we observe here. Recently, we became", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 248, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 505, + 261 + ], + "score": 1.0, + "content": "aware that Miyato et al. (2016) extended their work to CIFAR-10 and achieved state-of-the-art results", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 326, + 272 + ], + "score": 1.0, + "content": "(Miyato et al., 2017), surpassing our performance by", + "type": "text" + }, + { + "bbox": [ + 326, + 259, + 341, + 270 + ], + "score": 0.87, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 259, + 505, + 272 + ], + "score": 1.0, + "content": ". In future work, we plan to investigate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 271, + 490, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 490, + 283 + ], + "score": 1.0, + "content": "whether applying semantic loss on their architecture would yield an even stronger performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10 + }, + { + "type": "image", + "bbox": [ + 115, + 293, + 492, + 372 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 293, + 492, + 372 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 293, + 492, + 372 + ], + "spans": [ + { + "bbox": [ + 115, + 293, + 492, + 372 + ], + "score": 0.946, + "type": "image", + "image_path": "684ff625c16715167670292375e1562c7bf4528618063e9e1026bc8e042c3a58.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 115, + 293, + 492, + 319.3333333333333 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 115, + 319.3333333333333, + 492, + 345.66666666666663 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 115, + 345.66666666666663, + 492, + 371.99999999999994 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 380, + 503, + 403 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "Figure 3: FASHION pictures grouped by how confidently the supervised base model classifies them", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "correctly. With semantic loss, the final semi-supervised model predicts all correctly and confidently.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + } + ], + "index": 18.25 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 106, + 415, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 426 + ], + "score": 1.0, + "content": "Figure 3 illustrates the effect of semantic loss on FASHION pictures whose correct label was hidden", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "from the learner. Pictures 3a and 3b are correctly classified by the supervised base model, and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 312, + 449 + ], + "score": 1.0, + "content": "on the first set it is confident about this prediction", + "type": "text" + }, + { + "bbox": [ + 313, + 437, + 353, + 448 + ], + "score": 0.87, + "content": "( { \\mathsf p } _ { i } > 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 437, + 504, + 449 + ], + "score": 1.0, + "content": ". The semantic loss rarely diverts the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "model from these initially correct labels. However, it bootstraps these unlabeled examples to achieve", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "score": 1.0, + "content": "higher confidence in the learned concepts. With this additional learning signal, the model changes", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 469, + 504, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 504, + 482 + ], + "score": 1.0, + "content": "its beliefs about Pictures 3c, which it was previously uncertain about. Finally, even on confidently", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 481, + 498, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 498, + 492 + ], + "score": 1.0, + "content": "misclassified Pictures 3d, the semantic loss is able to fully correct the mistakes of the base model.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 107, + 507, + 344, + 521 + ], + "lines": [ + { + "bbox": [ + 104, + 506, + 344, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 506, + 344, + 523 + ], + "score": 1.0, + "content": "5 LEARNING WITH COMPLEX CONSTRAINTS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 532, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 532, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 505, + 545 + ], + "score": 1.0, + "content": "While much of current machine learning research is focused on problems such as multi-class clas-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 544, + 504, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 504, + 556 + ], + "score": 1.0, + "content": "sification, there remain a multitude of difficult problems involving highly constrained output do-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "mains. As mentioned in the previous section, semantic loss has little effect on the fully-supervised", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "exactly-one classification problem. This leads us to seek out more difficult problems to illustrate that", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "semantic loss can also be highly informative in the supervised case, provided the output domain is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "a sufficiently complex space. Because semantic loss is defined by a Boolean formula, it can be used", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "on any output domain that can be fully described in this manner. Here, we develop a framework for", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 610, + 496, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 496, + 621 + ], + "score": 1.0, + "content": "tractable semantic loss on highly complex constraints, and evaluate it on some difficult examples.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 108, + 634, + 266, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 634, + 268, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 268, + 647 + ], + "score": 1.0, + "content": "5.1 A TRACTABLE SEMANTIC LOSS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "score": 1.0, + "content": "Our goal here is to develop a method for computing both the semantic loss and its gradient in a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "tractable manner. Examining Definition 1 of semantic loss, we see that the right-hand side is a well-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "known automated reasoning task called weighted model counting (WMC) (Chavira & Darwiche,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "2008; Sang et al., 2005). A key property of WMC is that its partial derivatives can be computed in", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "terms of other, slightly modified WMCs. Furthermore, we know of circuit languages that compute", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "WMCs, and that are amenable to backpropagation (Darwiche, 2003). We use the language and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "circuit compilation techniques described in Darwiche (2011) to build a Boolean circuit representing", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 303, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 127 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "As shown in Table 3, our method compares favorably to ladder nets. However, due to the slight dif-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "ference in performance between the supervised base models, a direct comparison would be method-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "ologically flawed. Instead, we compare the net improvements over baselines. In terms of this mea-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 400, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 241, + 127 + ], + "score": 1.0, + "content": "sure, our method scores a gain of", + "type": "text" + }, + { + "bbox": [ + 241, + 115, + 268, + 126 + ], + "score": 0.88, + "content": "4 . { \\bar { 6 } } 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 116, + 370, + 127 + ], + "score": 1.0, + "content": "whereas ladder nets gain", + "type": "text" + }, + { + "bbox": [ + 370, + 115, + 397, + 126 + ], + "score": 0.88, + "content": "2 . 9 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 116, + 400, + 127 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 82, + 505, + 127 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 140, + 185, + 151 + ], + "lines": [ + { + "bbox": [ + 105, + 138, + 187, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 187, + 154 + ], + "score": 1.0, + "content": "4.3 DISCUSSION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 160, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 161, + 505, + 173 + ], + "score": 1.0, + "content": "Overall, the experiments so far have demonstrated the competitiveness and general applicability", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "of our proposed method on semi-supervised learning tasks. It surpassed the previous state of the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 182, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 506, + 196 + ], + "score": 1.0, + "content": "art (i.e. ladder nets ) on FASHION and CIFAR-10, while being close on MNIST. Considering the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "simplicity of our method, such results are encouraging. Indeed, a key advantage of semantic loss is", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 205, + 505, + 217 + ], + "score": 1.0, + "content": "that it only requires a simple additional loss term. Without changing the network architecture itself,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 216, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 229 + ], + "score": 1.0, + "content": "we incur almost no computational overhead. Conversely, this property makes our method sensitive to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "the underlying model’s performance. Without the underlying predictive power of a strong supervised", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "learning model, we do not expect to see the same benefits we observe here. Recently, we became", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 248, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 505, + 261 + ], + "score": 1.0, + "content": "aware that Miyato et al. (2016) extended their work to CIFAR-10 and achieved state-of-the-art results", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 326, + 272 + ], + "score": 1.0, + "content": "(Miyato et al., 2017), surpassing our performance by", + "type": "text" + }, + { + "bbox": [ + 326, + 259, + 341, + 270 + ], + "score": 0.87, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 259, + 505, + 272 + ], + "score": 1.0, + "content": ". In future work, we plan to investigate", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 271, + 490, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 490, + 283 + ], + "score": 1.0, + "content": "whether applying semantic loss on their architecture would yield an even stronger performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 161, + 506, + 283 + ] + }, + { + "type": "image", + "bbox": [ + 115, + 293, + 492, + 372 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 115, + 293, + 492, + 372 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 293, + 492, + 372 + ], + "spans": [ + { + "bbox": [ + 115, + 293, + 492, + 372 + ], + "score": 0.946, + "type": "image", + "image_path": "684ff625c16715167670292375e1562c7bf4528618063e9e1026bc8e042c3a58.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 115, + 293, + 492, + 319.3333333333333 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 115, + 319.3333333333333, + 492, + 345.66666666666663 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 115, + 345.66666666666663, + 492, + 371.99999999999994 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 380, + 503, + 403 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "Figure 3: FASHION pictures grouped by how confidently the supervised base model classifies them", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "correctly. With semantic loss, the final semi-supervised model predicts all correctly and confidently.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + } + ], + "index": 18.25 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 106, + 415, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 415, + 505, + 426 + ], + "score": 1.0, + "content": "Figure 3 illustrates the effect of semantic loss on FASHION pictures whose correct label was hidden", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 106, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "from the learner. Pictures 3a and 3b are correctly classified by the supervised base model, and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 437, + 504, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 312, + 449 + ], + "score": 1.0, + "content": "on the first set it is confident about this prediction", + "type": "text" + }, + { + "bbox": [ + 313, + 437, + 353, + 448 + ], + "score": 0.87, + "content": "( { \\mathsf p } _ { i } > 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 437, + 504, + 449 + ], + "score": 1.0, + "content": ". The semantic loss rarely diverts the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "model from these initially correct labels. However, it bootstraps these unlabeled examples to achieve", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "score": 1.0, + "content": "higher confidence in the learned concepts. With this additional learning signal, the model changes", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 469, + 504, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 504, + 482 + ], + "score": 1.0, + "content": "its beliefs about Pictures 3c, which it was previously uncertain about. Finally, even on confidently", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 481, + 498, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 498, + 492 + ], + "score": 1.0, + "content": "misclassified Pictures 3d, the semantic loss is able to fully correct the mistakes of the base model.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 415, + 505, + 492 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 507, + 344, + 521 + ], + "lines": [ + { + "bbox": [ + 104, + 506, + 344, + 523 + ], + "spans": [ + { + "bbox": [ + 104, + 506, + 344, + 523 + ], + "score": 1.0, + "content": "5 LEARNING WITH COMPLEX CONSTRAINTS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 532, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 532, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 505, + 545 + ], + "score": 1.0, + "content": "While much of current machine learning research is focused on problems such as multi-class clas-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 544, + 504, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 504, + 556 + ], + "score": 1.0, + "content": "sification, there remain a multitude of difficult problems involving highly constrained output do-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "mains. As mentioned in the previous section, semantic loss has little effect on the fully-supervised", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "exactly-one classification problem. This leads us to seek out more difficult problems to illustrate that", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "semantic loss can also be highly informative in the supervised case, provided the output domain is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "a sufficiently complex space. Because semantic loss is defined by a Boolean formula, it can be used", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "on any output domain that can be fully described in this manner. Here, we develop a framework for", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 610, + 496, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 496, + 621 + ], + "score": 1.0, + "content": "tractable semantic loss on highly complex constraints, and evaluate it on some difficult examples.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 532, + 506, + 621 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 634, + 266, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 634, + 268, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 268, + 647 + ], + "score": 1.0, + "content": "5.1 A TRACTABLE SEMANTIC LOSS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "score": 1.0, + "content": "Our goal here is to develop a method for computing both the semantic loss and its gradient in a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "tractable manner. Examining Definition 1 of semantic loss, we see that the right-hand side is a well-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "known automated reasoning task called weighted model counting (WMC) (Chavira & Darwiche,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "2008; Sang et al., 2005). A key property of WMC is that its partial derivatives can be computed in", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "terms of other, slightly modified WMCs. Furthermore, we know of circuit languages that compute", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "WMCs, and that are amenable to backpropagation (Darwiche, 2003). We use the language and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "circuit compilation techniques described in Darwiche (2011) to build a Boolean circuit representing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 229, + 505, + 242 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 505, + 242 + ], + "score": 1.0, + "content": "our semantic loss. We refer to the literature for details of this compilation approach. Due to certain", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 240, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 506, + 253 + ], + "score": 1.0, + "content": "properties of this circuit form, we can use it to compute both the values and the gradients of the", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 251, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 251, + 505, + 263 + ], + "score": 1.0, + "content": "semantic loss in time linear in the size of the circuit (Darwiche & Marquis, 2002). Once we have", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 263, + 493, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 493, + 274 + ], + "score": 1.0, + "content": "constructed this function, we can add it to our standard loss function as described in Section 4.1.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 654, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 171, + 100, + 440, + 137 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 135, + 80, + 475, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 476, + 94 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 476, + 94 + ], + "score": 1.0, + "content": "Table 4: Grid shortest path test results: coherent, incoherent and constraint accuracy.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 171, + 100, + 440, + 137 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 100, + 440, + 137 + ], + "spans": [ + { + "bbox": [ + 171, + 100, + 440, + 137 + ], + "score": 0.965, + "html": "
Test accuracy %CoherentIncoherentConstraint
5-layer MLP5.6285.916.99
With semantic loss (our)28.5183.1469.89
", + "type": "table", + "image_path": "ba42d7903b36e4520dcf1d5821e29357a1cf1180cc8d69b4a291aa60a57545f5.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 171, + 100, + 440, + 112.33333333333333 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 171, + 112.33333333333333, + 440, + 124.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 171, + 124.66666666666666, + 440, + 137.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 171, + 170, + 439, + 207 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 127, + 150, + 482, + 162 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 128, + 148, + 483, + 163 + ], + "spans": [ + { + "bbox": [ + 128, + 148, + 483, + 163 + ], + "score": 1.0, + "content": "Table 5: Preference prediction test results: coherent, incoherent and constraint accuracy.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 171, + 170, + 439, + 207 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 171, + 170, + 439, + 207 + ], + "spans": [ + { + "bbox": [ + 171, + 170, + 439, + 207 + ], + "score": 0.966, + "html": "
Test accuracy %CoherentIncoherentConstraint
3-layer MLP1.0175.782.72
With semantic loss (our)13.5972.4355.28
", + "type": "table", + "image_path": "fc01d806839dcd7d00573563b65a339ed59db17e31ff3c1aafedf315b18dc1ca.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 171, + 170, + 439, + 182.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 171, + 182.33333333333334, + 439, + 194.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 171, + 194.66666666666669, + 439, + 207.00000000000003 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 108, + 229, + 505, + 273 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 505, + 242 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 505, + 242 + ], + "score": 1.0, + "content": "our semantic loss. We refer to the literature for details of this compilation approach. Due to certain", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 240, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 506, + 253 + ], + "score": 1.0, + "content": "properties of this circuit form, we can use it to compute both the values and the gradients of the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 251, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 251, + 505, + 263 + ], + "score": 1.0, + "content": "semantic loss in time linear in the size of the circuit (Darwiche & Marquis, 2002). Once we have", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 263, + 493, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 493, + 274 + ], + "score": 1.0, + "content": "constructed this function, we can add it to our standard loss function as described in Section 4.1.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 108, + 290, + 257, + 302 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 259, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 259, + 303 + ], + "score": 1.0, + "content": "5.2 EXPERIMENTAL EVALUATION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 312, + 505, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "Our ambition when evaluating semantic loss’ performance on complex constraints is not to achieve", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "state-of-the-art performance on any particular problem, but rather to highlight its effect. To this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "end, we evaluate our method on problems with a difficult output space, where the model could no", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 346, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 506, + 358 + ], + "score": 1.0, + "content": "longer be fit directly from data, and purposefully use simple MLPs for evaluation. The details of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 356, + 329, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 329, + 369 + ], + "score": 1.0, + "content": "hyper-parameter tuning are again given in Appendix C.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 383, + 168, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 170, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 170, + 397 + ], + "score": 1.0, + "content": "5.2.1 GRIDS", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "We begin with a classic algorithmic problem, finding the shortest path in a graph. Specifically, we", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 180, + 428 + ], + "score": 1.0, + "content": "use a 4-by-4 grid", + "type": "text" + }, + { + "bbox": [ + 181, + 415, + 232, + 427 + ], + "score": 0.93, + "content": "G = ( V , E )", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "with uniform edge weights. We randomly remove edges for each", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 424, + 438 + ], + "score": 1.0, + "content": "example to increase difficulty. Formally, our input is a binary vector of length", + "type": "text" + }, + { + "bbox": [ + 425, + 426, + 465, + 438 + ], + "score": 0.92, + "content": "\\vert V \\vert + \\vert E \\vert", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 425, + 505, + 438 + ], + "score": 1.0, + "content": ", with the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 125, + 450 + ], + "score": 1.0, + "content": "first", + "type": "text" + }, + { + "bbox": [ + 126, + 437, + 140, + 448 + ], + "score": 0.88, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 437, + 380, + 450 + ], + "score": 1.0, + "content": "variables indicating sources and destinations, and the next", + "type": "text" + }, + { + "bbox": [ + 380, + 437, + 395, + 448 + ], + "score": 0.9, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "which edges are removed.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 446, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 300, + 462 + ], + "score": 1.0, + "content": "Similarly, each label is a binary vector of length", + "type": "text" + }, + { + "bbox": [ + 300, + 448, + 315, + 460 + ], + "score": 0.9, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 446, + 505, + 462 + ], + "score": 1.0, + "content": "indicating which edges are in the shortest path.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 279, + 471 + ], + "score": 1.0, + "content": "Finally, we require through our constraint", + "type": "text" + }, + { + "bbox": [ + 279, + 461, + 287, + 469 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 458, + 505, + 471 + ], + "score": 1.0, + "content": "that the output form a valid simple path between the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "desired source and destination. To compile this constraint, we use the method of Nishino et al.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 481, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 493 + ], + "score": 1.0, + "content": "(2017) to encode pairwise simple paths, and logically merge them to enforce the correct source and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 491, + 477, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 477, + 505 + ], + "score": 1.0, + "content": "destination. For more details on the constraint and data generation process, see Appendix D.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 509, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 522 + ], + "score": 1.0, + "content": "To evaluate, we use our generated dataset of 1600 examples, with a 60/20/20 train/validation/test", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "score": 1.0, + "content": "split. Table 4 compares test accuracy between a 5-layer MLP baseline, and the same model aug-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 531, + 504, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 504, + 542 + ], + "score": 1.0, + "content": "mented with semantic loss. We report three different accuracies that illustrate the effect of semantic", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "loss: “Coherent” indicates the percentage of examples for which the classifier gets the entire con-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "figuration right, while “Incoherent” measures the percentage of individually correct binary labels,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 562, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 505, + 577 + ], + "score": 1.0, + "content": "which as a whole may not constitute a valid path at all. Finally, “Constraint” describes the per-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 575, + 504, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 504, + 587 + ], + "score": 1.0, + "content": "centage of predictions given by the model that satisfy the constraint associated with the problem.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 586, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 598 + ], + "score": 1.0, + "content": "In the case of incoherent accuracy, semantic loss has little effect, and in fact slightly reduces the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 595, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 104, + 595, + 506, + 610 + ], + "score": 1.0, + "content": "accuracy as it combats the standard sigmoid cross entropy. In regard to coherent accuracy, however,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 621 + ], + "score": 1.0, + "content": "the semantic loss has a very large effect in guiding the network to jointly learn true paths, rather than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "optimizing each binary output individually. We further see this by observing the large increase in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 630, + 474, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 474, + 642 + ], + "score": 1.0, + "content": "the percentage of predictions which really are paths between the desired nodes in the graph.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33.5 + }, + { + "type": "title", + "bbox": [ + 108, + 656, + 245, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 246, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 246, + 669 + ], + "score": 1.0, + "content": "5.2.2 PREFERENCE LEARNING", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "The next problem we examine is that of predicting a complete order of preferences. That is, for a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "given set of user features, we would like to predict how the user would rank their preference over a", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 333, + 712 + ], + "score": 1.0, + "content": "fixed set of items. We encode a preference ordering over", + "type": "text" + }, + { + "bbox": [ + 333, + 702, + 340, + 709 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 697, + 475, + 712 + ], + "score": 1.0, + "content": "items as a flattened binary matrix", + "type": "text" + }, + { + "bbox": [ + 475, + 699, + 501, + 711 + ], + "score": 0.92, + "content": "\\{ X _ { i j } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 697, + 505, + 712 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 167, + 723 + ], + "score": 1.0, + "content": "where for each", + "type": "text" + }, + { + "bbox": [ + 168, + 709, + 236, + 722 + ], + "score": 0.9, + "content": "i , j \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 708, + 240, + 723 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 240, + 710, + 257, + 722 + ], + "score": 0.86, + "content": "X _ { i j }", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 708, + 328, + 723 + ], + "score": 1.0, + "content": "denotes that item", + "type": "text" + }, + { + "bbox": [ + 328, + 712, + 333, + 720 + ], + "score": 0.8, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 708, + 387, + 723 + ], + "score": 1.0, + "content": "is at position", + "type": "text" + }, + { + "bbox": [ + 387, + 711, + 392, + 721 + ], + "score": 0.8, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "(Choi et al., 2015). Clearly,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 361, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 361, + 734 + ], + "score": 1.0, + "content": "not all configurations of outputs correspond to a valid ordering.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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": "table", + "bbox": [ + 171, + 100, + 440, + 137 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 135, + 80, + 475, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 476, + 94 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 476, + 94 + ], + "score": 1.0, + "content": "Table 4: Grid shortest path test results: coherent, incoherent and constraint accuracy.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 171, + 100, + 440, + 137 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 100, + 440, + 137 + ], + "spans": [ + { + "bbox": [ + 171, + 100, + 440, + 137 + ], + "score": 0.965, + "html": "
Test accuracy %CoherentIncoherentConstraint
5-layer MLP5.6285.916.99
With semantic loss (our)28.5183.1469.89
", + "type": "table", + "image_path": "ba42d7903b36e4520dcf1d5821e29357a1cf1180cc8d69b4a291aa60a57545f5.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 171, + 100, + 440, + 112.33333333333333 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 171, + 112.33333333333333, + 440, + 124.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 171, + 124.66666666666666, + 440, + 137.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 171, + 170, + 439, + 207 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 127, + 150, + 482, + 162 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 128, + 148, + 483, + 163 + ], + "spans": [ + { + "bbox": [ + 128, + 148, + 483, + 163 + ], + "score": 1.0, + "content": "Table 5: Preference prediction test results: coherent, incoherent and constraint accuracy.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 171, + 170, + 439, + 207 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 171, + 170, + 439, + 207 + ], + "spans": [ + { + "bbox": [ + 171, + 170, + 439, + 207 + ], + "score": 0.966, + "html": "
Test accuracy %CoherentIncoherentConstraint
3-layer MLP1.0175.782.72
With semantic loss (our)13.5972.4355.28
", + "type": "table", + "image_path": "fc01d806839dcd7d00573563b65a339ed59db17e31ff3c1aafedf315b18dc1ca.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 171, + 170, + 439, + 182.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 171, + 182.33333333333334, + 439, + 194.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 171, + 194.66666666666669, + 439, + 207.00000000000003 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 108, + 229, + 505, + 273 + ], + "lines": [], + "index": 9.5, + "bbox_fs": [ + 105, + 229, + 506, + 274 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 290, + 257, + 302 + ], + "lines": [ + { + "bbox": [ + 105, + 290, + 259, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 259, + 303 + ], + "score": 1.0, + "content": "5.2 EXPERIMENTAL EVALUATION", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 312, + 505, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 325 + ], + "score": 1.0, + "content": "Our ambition when evaluating semantic loss’ performance on complex constraints is not to achieve", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "state-of-the-art performance on any particular problem, but rather to highlight its effect. To this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 505, + 347 + ], + "score": 1.0, + "content": "end, we evaluate our method on problems with a difficult output space, where the model could no", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 346, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 346, + 506, + 358 + ], + "score": 1.0, + "content": "longer be fit directly from data, and purposefully use simple MLPs for evaluation. The details of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 356, + 329, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 329, + 369 + ], + "score": 1.0, + "content": "hyper-parameter tuning are again given in Appendix C.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 312, + 506, + 369 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 383, + 168, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 170, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 170, + 397 + ], + "score": 1.0, + "content": "5.2.1 GRIDS", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 404, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 106, + 404, + 505, + 416 + ], + "score": 1.0, + "content": "We begin with a classic algorithmic problem, finding the shortest path in a graph. Specifically, we", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 180, + 428 + ], + "score": 1.0, + "content": "use a 4-by-4 grid", + "type": "text" + }, + { + "bbox": [ + 181, + 415, + 232, + 427 + ], + "score": 0.93, + "content": "G = ( V , E )", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "with uniform edge weights. We randomly remove edges for each", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 425, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 424, + 438 + ], + "score": 1.0, + "content": "example to increase difficulty. Formally, our input is a binary vector of length", + "type": "text" + }, + { + "bbox": [ + 425, + 426, + 465, + 438 + ], + "score": 0.92, + "content": "\\vert V \\vert + \\vert E \\vert", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 425, + 505, + 438 + ], + "score": 1.0, + "content": ", with the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 125, + 450 + ], + "score": 1.0, + "content": "first", + "type": "text" + }, + { + "bbox": [ + 126, + 437, + 140, + 448 + ], + "score": 0.88, + "content": "| V |", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 437, + 380, + 450 + ], + "score": 1.0, + "content": "variables indicating sources and destinations, and the next", + "type": "text" + }, + { + "bbox": [ + 380, + 437, + 395, + 448 + ], + "score": 0.9, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "which edges are removed.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 446, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 300, + 462 + ], + "score": 1.0, + "content": "Similarly, each label is a binary vector of length", + "type": "text" + }, + { + "bbox": [ + 300, + 448, + 315, + 460 + ], + "score": 0.9, + "content": "| E |", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 446, + 505, + 462 + ], + "score": 1.0, + "content": "indicating which edges are in the shortest path.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 458, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 279, + 471 + ], + "score": 1.0, + "content": "Finally, we require through our constraint", + "type": "text" + }, + { + "bbox": [ + 279, + 461, + 287, + 469 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 458, + 505, + 471 + ], + "score": 1.0, + "content": "that the output form a valid simple path between the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "desired source and destination. To compile this constraint, we use the method of Nishino et al.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 481, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 493 + ], + "score": 1.0, + "content": "(2017) to encode pairwise simple paths, and logically merge them to enforce the correct source and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 491, + 477, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 477, + 505 + ], + "score": 1.0, + "content": "destination. For more details on the constraint and data generation process, see Appendix D.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 404, + 506, + 505 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 509, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 508, + 506, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 506, + 522 + ], + "score": 1.0, + "content": "To evaluate, we use our generated dataset of 1600 examples, with a 60/20/20 train/validation/test", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 504, + 532 + ], + "score": 1.0, + "content": "split. Table 4 compares test accuracy between a 5-layer MLP baseline, and the same model aug-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 531, + 504, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 504, + 542 + ], + "score": 1.0, + "content": "mented with semantic loss. We report three different accuracies that illustrate the effect of semantic", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 541, + 505, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 555 + ], + "score": 1.0, + "content": "loss: “Coherent” indicates the percentage of examples for which the classifier gets the entire con-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "figuration right, while “Incoherent” measures the percentage of individually correct binary labels,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 562, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 505, + 577 + ], + "score": 1.0, + "content": "which as a whole may not constitute a valid path at all. Finally, “Constraint” describes the per-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 575, + 504, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 504, + 587 + ], + "score": 1.0, + "content": "centage of predictions given by the model that satisfy the constraint associated with the problem.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 586, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 598 + ], + "score": 1.0, + "content": "In the case of incoherent accuracy, semantic loss has little effect, and in fact slightly reduces the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 595, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 104, + 595, + 506, + 610 + ], + "score": 1.0, + "content": "accuracy as it combats the standard sigmoid cross entropy. In regard to coherent accuracy, however,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 607, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 621 + ], + "score": 1.0, + "content": "the semantic loss has a very large effect in guiding the network to jointly learn true paths, rather than", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 632 + ], + "score": 1.0, + "content": "optimizing each binary output individually. We further see this by observing the large increase in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 630, + 474, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 474, + 642 + ], + "score": 1.0, + "content": "the percentage of predictions which really are paths between the desired nodes in the graph.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 508, + 506, + 642 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 656, + 245, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 246, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 246, + 669 + ], + "score": 1.0, + "content": "5.2.2 PREFERENCE LEARNING", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "The next problem we examine is that of predicting a complete order of preferences. That is, for a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "given set of user features, we would like to predict how the user would rank their preference over a", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 333, + 712 + ], + "score": 1.0, + "content": "fixed set of items. We encode a preference ordering over", + "type": "text" + }, + { + "bbox": [ + 333, + 702, + 340, + 709 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 697, + 475, + 712 + ], + "score": 1.0, + "content": "items as a flattened binary matrix", + "type": "text" + }, + { + "bbox": [ + 475, + 699, + 501, + 711 + ], + "score": 0.92, + "content": "\\{ X _ { i j } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 697, + 505, + 712 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 167, + 723 + ], + "score": 1.0, + "content": "where for each", + "type": "text" + }, + { + "bbox": [ + 168, + 709, + 236, + 722 + ], + "score": 0.9, + "content": "i , j \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 708, + 240, + 723 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 240, + 710, + 257, + 722 + ], + "score": 0.86, + "content": "X _ { i j }", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 708, + 328, + 723 + ], + "score": 1.0, + "content": "denotes that item", + "type": "text" + }, + { + "bbox": [ + 328, + 712, + 333, + 720 + ], + "score": 0.8, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 708, + 387, + 723 + ], + "score": 1.0, + "content": "is at position", + "type": "text" + }, + { + "bbox": [ + 387, + 711, + 392, + 721 + ], + "score": 0.8, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "(Choi et al., 2015). Clearly,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 361, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 361, + 734 + ], + "score": 1.0, + "content": "not all configurations of outputs correspond to a valid ordering.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 677, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "For data, we use preference rankings over 10 types of sushi for 5000 individuals, taken from", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "PREFLIB (Mattei & Walsh, 2013). We take the ordering over 6 types of sushi as input features", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "score": 1.0, + "content": "to predict the ordering over the remaining 4 types, with splits identical to those in Shen et al. (2017).", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "We again split the data 60/20/20 into train/test/split, and employ a 3 layer MLP as our baseline.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "Table 5 compares the baseline to the same MLP augmented with semantic loss for valid total order-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 504, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 504, + 149 + ], + "score": 1.0, + "content": "ings. Again, we see that semantic loss has a marginal effect on incoherent accuracy, but massively", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "score": 1.0, + "content": "improves the network’s ability to predict valid, correct orderings. Remarkably, without semantic", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 453, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 341, + 172 + ], + "score": 1.0, + "content": "loss, the network is only able to output a valid ordering on", + "type": "text" + }, + { + "bbox": [ + 341, + 159, + 369, + 170 + ], + "score": 0.89, + "content": "0 . 0 1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 159, + 453, + 172 + ], + "score": 1.0, + "content": "of the test examples.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 108, + 186, + 210, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 184, + 213, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 213, + 201 + ], + "score": 1.0, + "content": "6 RELATED WORK", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 210, + 504, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 504, + 223 + ], + "score": 1.0, + "content": "Incorporating symbolic background knowledge into machine learning is a long-standing chal-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "lenge (Srinivasan et al., 1995). It has received considerable attention for structured prediction in", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "natural language processing, in both supervised and semi-supervised settings. For example, con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "strained conditional models extend linear models with constraints that are enforced through integer", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 506, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 506, + 267 + ], + "score": 1.0, + "content": "linear programming (Chang et al., 2008; 2013). Constraints have also been studied in the context", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "score": 1.0, + "content": "of probabilistic graphical models (Mateescu & Dechter, 2008; Ganchev et al., 2010). Kisa et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 290 + ], + "score": 1.0, + "content": "(2014) utilize a circuit language called the probabilistic sentential decision diagram to induce dis-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "tributions over arbitrary logical formulas. They learn generative models that satisfy preference and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 297, + 468, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 468, + 313 + ], + "score": 1.0, + "content": "path constraints (Choi et al., 2015; 2016), which we both study in a discriminative setting.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 436 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "score": 1.0, + "content": "Various deep learning techniques have been proposed to enforce either arithmetic constraints (Pathak", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "et al., 2015; Marquez-Neila et al., 2017) or logical constraints (Rockt ´ aschel et al., 2015; Hu et al., ¨", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 337, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 349 + ], + "score": 1.0, + "content": "2016; Demeester et al., 2016; Stewart & Ermon, 2017; Minervini et al., 2017; Diligenti et al., 2017;", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Donadello et al., 2017) on the output of a neural network. The common approach is to reduce logical", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 358, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 104, + 358, + 505, + 373 + ], + "score": 1.0, + "content": "constraints into differentiable arithmetic objectives by replacing logical operators with their fuzzy", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "score": 1.0, + "content": "t-norms and logical implications with simple inequalities. A downside of this fuzzy relaxation is that", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "the logical sentences lose their precise meaning. The learning objective becomes a function of the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 392, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 505, + 405 + ], + "score": 1.0, + "content": "syntax rather than the semantics. Moreover, these relaxations are often only applied to Horn clauses.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 402, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 416 + ], + "score": 1.0, + "content": "One alternative is to encode the logic into a factor graph and perform loopy belief propagation to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "compute a loss function (Naradowsky & Riedel, 2017), which is known to have issues in the presence", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 425, + 331, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 331, + 438 + ], + "score": 1.0, + "content": "of complex logical constraints (Smith & Gogate, 2014).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 530 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "Several specialized techniques have been proposed to exploit the rich structure of real world labels.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 452, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 104, + 452, + 506, + 465 + ], + "score": 1.0, + "content": "Deng et al. (2014) propose hierarchy and exclusion graphs that allow a flexible joint modeling of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "hierarchical categories. It is a method invented to address examples whose labels are not provided", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "at the most specific level. Finally, the objective of semantic loss to increase the confidence of pre-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "dictions on unlabeled data is in common with information-theoretic approaches to semi-supervised", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "score": 1.0, + "content": "learning (Grandvalet & Bengio, 2005; Erkan & Altun, 2010), and approaches that increase robust-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 509, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 519 + ], + "score": 1.0, + "content": "ness to output perturbation (Miyato et al., 2016). A key difference between semantic loss and these", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 518, + 473, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 473, + 531 + ], + "score": 1.0, + "content": "information-theoretic losses is that semantic loss generalizes to arbitrary output constraints.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 108, + 545, + 201, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 203, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 203, + 561 + ], + "score": 1.0, + "content": "7 CONCLUSIONS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "Both reasoning and semi-supervised learning are often identified as key challenges for deep learning", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "going forward. In this paper, we developed a principled way of combining automated reasoning", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 592, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 505, + 604 + ], + "score": 1.0, + "content": "for propositional logic with existing deep learning architectures. Moreover, we showed that our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "semantic loss function provides significant benefits during semi-supervised classification, as well as", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 614, + 350, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 350, + 627 + ], + "score": 1.0, + "content": "deep structured prediction for highly complex output spaces.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "title", + "bbox": [ + 108, + 641, + 175, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 177, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 177, + 655 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 108, + 659, + 503, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "Mikhail Bilenko, Sugato Basu, and Raymond J Mooney. Integrating constraints and metric learn-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 115, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "ing in semi-supervised clustering. In Proceedings of the International Conference on Machine", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 681, + 240, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 240, + 693 + ], + "score": 1.0, + "content": "learning, pp. 11. ACM, 2004.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "score": 1.0, + "content": "Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 117, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 117, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Translating embeddings for modeling multi-relational data. In Advances in neural information", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 115, + 721, + 287, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 287, + 732 + ], + "score": 1.0, + "content": "processing systems, pp. 2787–2795, 2013.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "For data, we use preference rankings over 10 types of sushi for 5000 individuals, taken from", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "PREFLIB (Mattei & Walsh, 2013). We take the ordering over 6 types of sushi as input features", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "score": 1.0, + "content": "to predict the ordering over the remaining 4 types, with splits identical to those in Shen et al. (2017).", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "We again split the data 60/20/20 into train/test/split, and employ a 3 layer MLP as our baseline.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "Table 5 compares the baseline to the same MLP augmented with semantic loss for valid total order-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 504, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 504, + 149 + ], + "score": 1.0, + "content": "ings. Again, we see that semantic loss has a marginal effect on incoherent accuracy, but massively", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "score": 1.0, + "content": "improves the network’s ability to predict valid, correct orderings. Remarkably, without semantic", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 453, + 172 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 341, + 172 + ], + "score": 1.0, + "content": "loss, the network is only able to output a valid ordering on", + "type": "text" + }, + { + "bbox": [ + 341, + 159, + 369, + 170 + ], + "score": 0.89, + "content": "0 . 0 1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 159, + 453, + 172 + ], + "score": 1.0, + "content": "of the test examples.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 83, + 505, + 172 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 186, + 210, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 184, + 213, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 213, + 201 + ], + "score": 1.0, + "content": "6 RELATED WORK", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 210, + 504, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 504, + 223 + ], + "score": 1.0, + "content": "Incorporating symbolic background knowledge into machine learning is a long-standing chal-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "lenge (Srinivasan et al., 1995). It has received considerable attention for structured prediction in", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "natural language processing, in both supervised and semi-supervised settings. For example, con-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 256 + ], + "score": 1.0, + "content": "strained conditional models extend linear models with constraints that are enforced through integer", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 506, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 506, + 267 + ], + "score": 1.0, + "content": "linear programming (Chang et al., 2008; 2013). Constraints have also been studied in the context", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 279 + ], + "score": 1.0, + "content": "of probabilistic graphical models (Mateescu & Dechter, 2008; Ganchev et al., 2010). Kisa et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 276, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 290 + ], + "score": 1.0, + "content": "(2014) utilize a circuit language called the probabilistic sentential decision diagram to induce dis-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "tributions over arbitrary logical formulas. They learn generative models that satisfy preference and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 297, + 468, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 468, + 313 + ], + "score": 1.0, + "content": "path constraints (Choi et al., 2015; 2016), which we both study in a discriminative setting.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 210, + 506, + 313 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 436 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "score": 1.0, + "content": "Various deep learning techniques have been proposed to enforce either arithmetic constraints (Pathak", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "et al., 2015; Marquez-Neila et al., 2017) or logical constraints (Rockt ´ aschel et al., 2015; Hu et al., ¨", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 337, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 349 + ], + "score": 1.0, + "content": "2016; Demeester et al., 2016; Stewart & Ermon, 2017; Minervini et al., 2017; Diligenti et al., 2017;", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "Donadello et al., 2017) on the output of a neural network. The common approach is to reduce logical", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 358, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 104, + 358, + 505, + 373 + ], + "score": 1.0, + "content": "constraints into differentiable arithmetic objectives by replacing logical operators with their fuzzy", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 383 + ], + "score": 1.0, + "content": "t-norms and logical implications with simple inequalities. A downside of this fuzzy relaxation is that", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "the logical sentences lose their precise meaning. The learning objective becomes a function of the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 392, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 505, + 405 + ], + "score": 1.0, + "content": "syntax rather than the semantics. Moreover, these relaxations are often only applied to Horn clauses.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 402, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 416 + ], + "score": 1.0, + "content": "One alternative is to encode the logic into a factor graph and perform loopy belief propagation to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "compute a loss function (Naradowsky & Riedel, 2017), which is known to have issues in the presence", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 425, + 331, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 331, + 438 + ], + "score": 1.0, + "content": "of complex logical constraints (Smith & Gogate, 2014).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23, + "bbox_fs": [ + 104, + 315, + 506, + 438 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 442, + 505, + 530 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "Several specialized techniques have been proposed to exploit the rich structure of real world labels.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 452, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 104, + 452, + 506, + 465 + ], + "score": 1.0, + "content": "Deng et al. (2014) propose hierarchy and exclusion graphs that allow a flexible joint modeling of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "hierarchical categories. It is a method invented to address examples whose labels are not provided", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "at the most specific level. Finally, the objective of semantic loss to increase the confidence of pre-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "dictions on unlabeled data is in common with information-theoretic approaches to semi-supervised", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 509 + ], + "score": 1.0, + "content": "learning (Grandvalet & Bengio, 2005; Erkan & Altun, 2010), and approaches that increase robust-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 509, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 505, + 519 + ], + "score": 1.0, + "content": "ness to output perturbation (Miyato et al., 2016). A key difference between semantic loss and these", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 518, + 473, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 473, + 531 + ], + "score": 1.0, + "content": "information-theoretic losses is that semantic loss generalizes to arbitrary output constraints.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32.5, + "bbox_fs": [ + 104, + 441, + 506, + 531 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 545, + 201, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 203, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 203, + 561 + ], + "score": 1.0, + "content": "7 CONCLUSIONS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "Both reasoning and semi-supervised learning are often identified as key challenges for deep learning", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "going forward. In this paper, we developed a principled way of combining automated reasoning", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 592, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 505, + 604 + ], + "score": 1.0, + "content": "for propositional logic with existing deep learning architectures. Moreover, we showed that our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "semantic loss function provides significant benefits during semi-supervised classification, as well as", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 614, + 350, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 350, + 627 + ], + "score": 1.0, + "content": "deep structured prediction for highly complex output spaces.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 569, + 505, + 627 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 641, + 175, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 177, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 177, + 655 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 108, + 659, + 503, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 672 + ], + "score": 1.0, + "content": "Mikhail Bilenko, Sugato Basu, and Raymond J Mooney. Integrating constraints and metric learn-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 115, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "ing in semi-supervised clustering. In Proceedings of the International Conference on Machine", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 681, + 240, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 240, + 693 + ], + "score": 1.0, + "content": "learning, pp. 11. ACM, 2004.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 658, + 505, + 693 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "score": 1.0, + "content": "Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 117, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 117, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Translating embeddings for modeling multi-relational data. In Advances in neural information", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 115, + 721, + 287, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 287, + 732 + ], + "score": 1.0, + "content": "processing systems, pp. 2787–2795, 2013.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48, + "bbox_fs": [ + 106, + 698, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Kai-Wei Chang, Rajhans Samdani, and Dan Roth. A constrained latent variable model for corefer-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 208, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 208, + 104 + ], + "score": 1.0, + "content": "ence resolution. 2013.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "Ming-Wei Chang, Lev-Arie Ratinov, Nicholas Rizzolo, and Dan Roth. Learning and inference with", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 123, + 292, + 135 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 292, + 135 + ], + "score": 1.0, + "content": "constraints. In AAAI, pp. 1513–1518, 2008.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 504, + 165 + ], + "lines": [ + { + "bbox": [ + 105, + 141, + 504, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 504, + 155 + ], + "score": 1.0, + "content": "Mark Chavira and Adnan Darwiche. On probabilistic inference by weighted model counting. Arti-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 153, + 290, + 165 + ], + "spans": [ + { + "bbox": [ + 114, + 153, + 290, + 165 + ], + "score": 1.0, + "content": "ficial Intelligence, 172(6):772 – 799, 2008.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 106, + 172, + 504, + 207 + ], + "lines": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "Arthur Choi, Guy Van den Broeck, and Adnan Darwiche. Tractable learning for structured probabil-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 183, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 115, + 183, + 506, + 196 + ], + "score": 1.0, + "content": "ity spaces: A case study in learning preference distributions. In Proceedings of 24th International", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 195, + 347, + 207 + ], + "spans": [ + { + "bbox": [ + 116, + 195, + 347, + 207 + ], + "score": 1.0, + "content": "Joint Conference on Artificial Intelligence (IJCAI), 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 103, + 212, + 504, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 227 + ], + "score": 1.0, + "content": "Arthur Choi, Nazgol Tavabi, and Adnan Darwiche. Structured features in naive Bayes classification.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 224, + 306, + 237 + ], + "spans": [ + { + "bbox": [ + 116, + 224, + 306, + 237 + ], + "score": 1.0, + "content": "In Proceedings of AAAI, pp. 3233–3240, 2016.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 104, + 243, + 504, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Adnan Darwiche. A differential approach to inference in bayesian networks. J. ACM, 50(3):280–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 254, + 377, + 266 + ], + "spans": [ + { + "bbox": [ + 116, + 254, + 377, + 266 + ], + "score": 1.0, + "content": "305, May 2003. ISSN 0004-5411. doi: 10.1145/765568.765570.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 273, + 503, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "Adnan Darwiche. SDD: A new canonical representation of propositional knowledge bases. In IJCAI", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 284, + 504, + 297 + ], + "spans": [ + { + "bbox": [ + 116, + 284, + 504, + 297 + ], + "score": 1.0, + "content": "Proceedings-International Joint Conference on Artificial Intelligence, volume 22, pp. 819, 2011.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 302, + 503, + 326 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "Adnan Darwiche and Pierre Marquis. A knowledge compilation map. Journal of Artificial Intelli-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 314, + 261, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 261, + 326 + ], + "score": 1.0, + "content": "gence Research, 17:229–264, 2002.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 332, + 503, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 504, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 504, + 346 + ], + "score": 1.0, + "content": "Hal Daume, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine learn-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 344, + 223, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 223, + 356 + ], + "score": 1.0, + "content": "ing, 75(3):297–325, 2009.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 362, + 504, + 397 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 504, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 504, + 376 + ], + "score": 1.0, + "content": "Thomas Demeester, Tim Rocktaschel, and Sebastian Riedel. Lifted rule injection for relation em- ¨", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 373, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 115, + 373, + 505, + 388 + ], + "score": 1.0, + "content": "beddings. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 385, + 482, + 398 + ], + "spans": [ + { + "bbox": [ + 116, + 385, + 482, + 398 + ], + "score": 1.0, + "content": "Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 1389–1399, 2016.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 504, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "score": 1.0, + "content": "Deng, Nan Ding, Yangqing Jia, Andrea Frome, Kevin Murphy, Samy Bengio, Yuan Li, Hartmut", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 116, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "Neven, and Hartwig Adam. Large-scale object classification using label relation graphs. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 426, + 230, + 437 + ], + "spans": [ + { + "bbox": [ + 116, + 426, + 230, + 437 + ], + "score": 1.0, + "content": "ECCV, volume 8689, 2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 442, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 442, + 506, + 460 + ], + "score": 1.0, + "content": "Michelangelo Diligenti, Marco Gori, and Claudio Sacca. Semantic-based regularization for learning", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 456, + 349, + 468 + ], + "spans": [ + { + "bbox": [ + 115, + 456, + 349, + 468 + ], + "score": 1.0, + "content": "and inference. Artificial Intelligence, 244:143–165, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 474, + 505, + 508 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Ivan Donadello, Luciano Serafini, and Artur d’Avila Garcez. Logic tensor networks for semantic", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 485, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 115, + 485, + 506, + 500 + ], + "score": 1.0, + "content": "image interpretation. In International Joint Conference on Artificial Intelligence, pp. 1596–1602,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 496, + 144, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 144, + 509 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 515, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 106, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 527, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 116, + 527, + 505, + 539 + ], + "score": 1.0, + "content": "Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 537, + 478, + 551 + ], + "spans": [ + { + "bbox": [ + 115, + 537, + 478, + 551 + ], + "score": 1.0, + "content": "fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 504, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "Ayse Erkan and Yasemin Altun. Semi-supervised learning via generalized maximum entropy. In", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 566, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 566, + 505, + 581 + ], + "score": 1.0, + "content": "Thirteenth International Conference on Artificial Intelligence and Statistics, volume PMLR, pp.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 579, + 181, + 590 + ], + "spans": [ + { + "bbox": [ + 116, + 579, + 181, + 590 + ], + "score": 1.0, + "content": "209–216, 2010.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 106, + 597, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "Kuzman Ganchev, Jennifer Gillenwater, Ben Taskar, et al. Posterior regularization for structured", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 608, + 477, + 621 + ], + "spans": [ + { + "bbox": [ + 115, + 608, + 477, + 621 + ], + "score": 1.0, + "content": "latent variable models. Journal of Machine Learning Research, 11(Jul):2001–2049, 2010.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 105, + 627, + 504, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 627, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 641 + ], + "score": 1.0, + "content": "Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Ad-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 639, + 394, + 651 + ], + "spans": [ + { + "bbox": [ + 115, + 639, + 394, + 651 + ], + "score": 1.0, + "content": "vances in neural information processing systems, pp. 529–536, 2005.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 107, + 657, + 505, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 657, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 505, + 670 + ], + "score": 1.0, + "content": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 667, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 115, + 667, + 505, + 681 + ], + "score": 1.0, + "content": "Barwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 679, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 679, + 505, + 692 + ], + "score": 1.0, + "content": "et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 690, + 210, + 703 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 210, + 703 + ], + "score": 1.0, + "content": "(7626):471–476, 2016.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "Trevor Hastie, Robert Tibshirani, and Jerome Friedman. Overview of supervised learning. In The", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 720, + 348, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 348, + 733 + ], + "score": 1.0, + "content": "elements of statistical learning, pp. 9–41. Springer, 2009.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Kai-Wei Chang, Rajhans Samdani, and Dan Roth. A constrained latent variable model for corefer-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 208, + 104 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 208, + 104 + ], + "score": 1.0, + "content": "ence resolution. 2013.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 82, + 505, + 104 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "Ming-Wei Chang, Lev-Arie Ratinov, Nicholas Rizzolo, and Dan Roth. Learning and inference with", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 116, + 123, + 292, + 135 + ], + "spans": [ + { + "bbox": [ + 116, + 123, + 292, + 135 + ], + "score": 1.0, + "content": "constraints. In AAAI, pp. 1513–1518, 2008.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 106, + 112, + 505, + 135 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 142, + 504, + 165 + ], + "lines": [ + { + "bbox": [ + 105, + 141, + 504, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 504, + 155 + ], + "score": 1.0, + "content": "Mark Chavira and Adnan Darwiche. On probabilistic inference by weighted model counting. Arti-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 153, + 290, + 165 + ], + "spans": [ + { + "bbox": [ + 114, + 153, + 290, + 165 + ], + "score": 1.0, + "content": "ficial Intelligence, 172(6):772 – 799, 2008.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 141, + 504, + 165 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 172, + 504, + 207 + ], + "lines": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 185 + ], + "score": 1.0, + "content": "Arthur Choi, Guy Van den Broeck, and Adnan Darwiche. Tractable learning for structured probabil-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 183, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 115, + 183, + 506, + 196 + ], + "score": 1.0, + "content": "ity spaces: A case study in learning preference distributions. In Proceedings of 24th International", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 195, + 347, + 207 + ], + "spans": [ + { + "bbox": [ + 116, + 195, + 347, + 207 + ], + "score": 1.0, + "content": "Joint Conference on Artificial Intelligence (IJCAI), 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 106, + 172, + 506, + 207 + ] + }, + { + "type": "text", + "bbox": [ + 103, + 212, + 504, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 227 + ], + "score": 1.0, + "content": "Arthur Choi, Nazgol Tavabi, and Adnan Darwiche. Structured features in naive Bayes classification.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 116, + 224, + 306, + 237 + ], + "spans": [ + { + "bbox": [ + 116, + 224, + 306, + 237 + ], + "score": 1.0, + "content": "In Proceedings of AAAI, pp. 3233–3240, 2016.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 211, + 505, + 237 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 243, + 504, + 266 + ], + "lines": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 255 + ], + "score": 1.0, + "content": "Adnan Darwiche. A differential approach to inference in bayesian networks. J. ACM, 50(3):280–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 254, + 377, + 266 + ], + "spans": [ + { + "bbox": [ + 116, + 254, + 377, + 266 + ], + "score": 1.0, + "content": "305, May 2003. ISSN 0004-5411. doi: 10.1145/765568.765570.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 242, + 505, + 266 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 273, + 503, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "Adnan Darwiche. SDD: A new canonical representation of propositional knowledge bases. In IJCAI", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 284, + 504, + 297 + ], + "spans": [ + { + "bbox": [ + 116, + 284, + 504, + 297 + ], + "score": 1.0, + "content": "Proceedings-International Joint Conference on Artificial Intelligence, volume 22, pp. 819, 2011.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 273, + 505, + 297 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 302, + 503, + 326 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "Adnan Darwiche and Pierre Marquis. A knowledge compilation map. Journal of Artificial Intelli-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 314, + 261, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 261, + 326 + ], + "score": 1.0, + "content": "gence Research, 17:229–264, 2002.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 106, + 303, + 505, + 326 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 332, + 503, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 504, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 504, + 346 + ], + "score": 1.0, + "content": "Hal Daume, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine learn-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 344, + 223, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 223, + 356 + ], + "score": 1.0, + "content": "ing, 75(3):297–325, 2009.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 332, + 504, + 356 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 362, + 504, + 397 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 504, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 504, + 376 + ], + "score": 1.0, + "content": "Thomas Demeester, Tim Rocktaschel, and Sebastian Riedel. Lifted rule injection for relation em- ¨", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 373, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 115, + 373, + 505, + 388 + ], + "score": 1.0, + "content": "beddings. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 385, + 482, + 398 + ], + "spans": [ + { + "bbox": [ + 116, + 385, + 482, + 398 + ], + "score": 1.0, + "content": "Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 1389–1399, 2016.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 362, + 505, + 398 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 504, + 438 + ], + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "score": 1.0, + "content": "Deng, Nan Ding, Yangqing Jia, Andrea Frome, Kevin Murphy, Samy Bengio, Yuan Li, Hartmut", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 415, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 116, + 415, + 505, + 428 + ], + "score": 1.0, + "content": "Neven, and Hartwig Adam. Large-scale object classification using label relation graphs. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 426, + 230, + 437 + ], + "spans": [ + { + "bbox": [ + 116, + 426, + 230, + 437 + ], + "score": 1.0, + "content": "ECCV, volume 8689, 2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 403, + 505, + 437 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 504, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 442, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 442, + 506, + 460 + ], + "score": 1.0, + "content": "Michelangelo Diligenti, Marco Gori, and Claudio Sacca. Semantic-based regularization for learning", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 456, + 349, + 468 + ], + "spans": [ + { + "bbox": [ + 115, + 456, + 349, + 468 + ], + "score": 1.0, + "content": "and inference. Artificial Intelligence, 244:143–165, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 104, + 442, + 506, + 468 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 474, + 505, + 508 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Ivan Donadello, Luciano Serafini, and Artur d’Avila Garcez. Logic tensor networks for semantic", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 485, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 115, + 485, + 506, + 500 + ], + "score": 1.0, + "content": "image interpretation. In International Joint Conference on Artificial Intelligence, pp. 1596–1602,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 496, + 144, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 144, + 509 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 474, + 506, + 509 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 515, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 106, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 527, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 116, + 527, + 505, + 539 + ], + "score": 1.0, + "content": "Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 537, + 478, + 551 + ], + "spans": [ + { + "bbox": [ + 115, + 537, + 478, + 551 + ], + "score": 1.0, + "content": "fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31, + "bbox_fs": [ + 106, + 515, + 505, + 551 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 556, + 504, + 591 + ], + "lines": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "Ayse Erkan and Yasemin Altun. Semi-supervised learning via generalized maximum entropy. In", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 566, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 566, + 505, + 581 + ], + "score": 1.0, + "content": "Thirteenth International Conference on Artificial Intelligence and Statistics, volume PMLR, pp.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 579, + 181, + 590 + ], + "spans": [ + { + "bbox": [ + 116, + 579, + 181, + 590 + ], + "score": 1.0, + "content": "209–216, 2010.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 556, + 505, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 597, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "Kuzman Ganchev, Jennifer Gillenwater, Ben Taskar, et al. Posterior regularization for structured", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 608, + 477, + 621 + ], + "spans": [ + { + "bbox": [ + 115, + 608, + 477, + 621 + ], + "score": 1.0, + "content": "latent variable models. Journal of Machine Learning Research, 11(Jul):2001–2049, 2010.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 597, + 505, + 621 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 627, + 504, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 627, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 641 + ], + "score": 1.0, + "content": "Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Ad-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 639, + 394, + 651 + ], + "spans": [ + { + "bbox": [ + 115, + 639, + 394, + 651 + ], + "score": 1.0, + "content": "vances in neural information processing systems, pp. 529–536, 2005.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 627, + 505, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 657, + 505, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 657, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 505, + 670 + ], + "score": 1.0, + "content": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 667, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 115, + 667, + 505, + 681 + ], + "score": 1.0, + "content": "Barwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 679, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 115, + 679, + 505, + 692 + ], + "score": 1.0, + "content": "et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 116, + 690, + 210, + 703 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 210, + 703 + ], + "score": 1.0, + "content": "(7626):471–476, 2016.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 657, + 505, + 703 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 504, + 722 + ], + "score": 1.0, + "content": "Trevor Hastie, Robert Tibshirani, and Jerome Friedman. Overview of supervised learning. In The", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 720, + 348, + 733 + ], + "spans": [ + { + "bbox": [ + 116, + 720, + 348, + 733 + ], + "score": 1.0, + "content": "elements of statistical learning, pp. 9–41. Springer, 2009.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 106, + 709, + 504, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "score": 1.0, + "content": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "nition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 126 + ], + "score": 1.0, + "content": "Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric Xing. Harnessing deep neural", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 282, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 282, + 135 + ], + "score": 1.0, + "content": "networks with logic rules. In ACL, 2016.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 109, + 141, + 504, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 140, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 155 + ], + "score": 1.0, + "content": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 505, + 165 + ], + "score": 1.0, + "content": "reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 143, + 176 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 143, + 176 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 181, + 430, + 194 + ], + "lines": [ + { + "bbox": [ + 105, + 181, + 427, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 427, + 195 + ], + "score": 1.0, + "content": "Douglas Samuel Jones. Elementary information theory. Clarendon Press, 1979.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 105, + 200, + 473, + 212 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 475, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 475, + 214 + ], + "score": 1.0, + "content": "Diederik P Kingma and Jimmy Lei Ba. Adam: A method for stochastic optimization. 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 219, + 506, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 219, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 219, + 505, + 231 + ], + "score": 1.0, + "content": "Diederik P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 229, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 229, + 506, + 243 + ], + "score": 1.0, + "content": "learning with deep generative models. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 241, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 115, + 241, + 506, + 254 + ], + "score": 1.0, + "content": "and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 3581–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 253, + 264, + 263 + ], + "spans": [ + { + "bbox": [ + 116, + 253, + 264, + 263 + ], + "score": 1.0, + "content": "3589. Curran Associates, Inc., 2014.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 270, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "Doga Kisa, Guy Van den Broeck, Arthur Choi, and Adnan Darwiche. Probabilistic sentential deci-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 282, + 294, + 293 + ], + "spans": [ + { + "bbox": [ + 116, + 282, + 294, + 293 + ], + "score": 1.0, + "content": "sion diagrams. In Proceedings of KR, 2014.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 299, + 504, + 312 + ], + "lines": [ + { + "bbox": [ + 106, + 299, + 504, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 504, + 313 + ], + "score": 1.0, + "content": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 503, + 353 + ], + "lines": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classifcation with deep convo-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 329, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 329, + 505, + 343 + ], + "score": 1.0, + "content": "lutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.),", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 341, + 432, + 353 + ], + "spans": [ + { + "bbox": [ + 115, + 341, + 432, + 353 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems 25, pp. 1097–1105, 2012.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 105, + 359, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 504, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 504, + 372 + ], + "score": 1.0, + "content": "Pablo Marquez-Neila, Mathieu Salzmann, and Pascal Fua. Imposing hard constraints on deep net-´", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 370, + 414, + 382 + ], + "spans": [ + { + "bbox": [ + 115, + 370, + 414, + 382 + ], + "score": 1.0, + "content": "works: Promises and limitations. arXiv preprint arXiv:1706.02025, 2017.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 105, + 388, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 507, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 507, + 402 + ], + "score": 1.0, + "content": "Robert Mateescu and Rina Dechter. Mixed deterministic and probabilistic networks. Annals of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 400, + 343, + 412 + ], + "spans": [ + { + "bbox": [ + 115, + 400, + 343, + 412 + ], + "score": 1.0, + "content": "mathematics and artificial intelligence, 54(1-3):3, 2008.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 105, + 418, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "Nicholas Mattei and Toby Walsh. Preflib: A library of preference data HTTP://PREFLIB.ORG. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 428, + 227, + 441 + ], + "spans": [ + { + "bbox": [ + 115, + 428, + 227, + 441 + ], + "score": 1.0, + "content": "Proceedings of ADT, 2013.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 504, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 504, + 460 + ], + "score": 1.0, + "content": "Pasquale Minervini, Thomas Demeester, Tim Rocktaschel, and Sebastian Riedel. Adversarial sets ¨", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 459, + 435, + 471 + ], + "spans": [ + { + "bbox": [ + 115, + 459, + 435, + 471 + ], + "score": 1.0, + "content": "for regularising neural link predictors. arXiv preprint arXiv:1707.07596, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 105, + 477, + 504, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 489, + 355, + 501 + ], + "spans": [ + { + "bbox": [ + 115, + 489, + 355, + 501 + ], + "score": 1.0, + "content": "smoothing with virtual adversarial training. In ICLR, 2016.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 108, + 506, + 504, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Virtual adversarial", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 115, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "training: a regularization method for supervised and semi-supervised learning. ArXiv e-prints,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 528, + 144, + 541 + ], + "spans": [ + { + "bbox": [ + 115, + 528, + 144, + 541 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 109, + 547, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 107, + 547, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 107, + 547, + 505, + 561 + ], + "score": 1.0, + "content": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "In Proceedings of the 27th International Conference on International Conference on Machine", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 569, + 285, + 582 + ], + "spans": [ + { + "bbox": [ + 116, + 569, + 285, + 582 + ], + "score": 1.0, + "content": "Learning, pp. 807–814. Omnipress, 2010.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 104, + 587, + 504, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 601 + ], + "score": 1.0, + "content": "Jason Naradowsky and Sebastian Riedel. Modeling exclusion with a differentiable factor graph", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 599, + 465, + 611 + ], + "spans": [ + { + "bbox": [ + 116, + 599, + 465, + 611 + ], + "score": 1.0, + "content": "constraint. In International Conference on Machine Learning (Workshop Track), 2017.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 617, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Benjamin Roth, and Andrew McCallum. Compositional vector space models", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 629, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 115, + 629, + 505, + 641 + ], + "score": 1.0, + "content": "for knowledge base inference. In Proceedings of the 53rd Annual Meeting of the Association", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 114, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "for Computational Linguistics and the 7th International Joint Conference on Natural Language", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 650, + 245, + 662 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 245, + 662 + ], + "score": 1.0, + "content": "Processing, pp. 156–166, 2015.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 106, + 668, + 503, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural net-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 680, + 485, + 692 + ], + "spans": [ + { + "bbox": [ + 116, + 680, + 485, + 692 + ], + "score": 1.0, + "content": "works for graphs. In International Conference on Machine Learning, pp. 2014–2023, 2016.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "score": 1.0, + "content": "Masaaki Nishino, Norihito Yasuda, Shin-ichi Minato, and Masaaki Nagata. Compiling graph sub-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "structures into sentential decision diagrams. In Proceedings of the Thirty-First Conference on", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 720, + 263, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 263, + 733 + ], + "score": 1.0, + "content": "Artificial Intelligence (AAAI), 2017.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 97 + ], + "score": 1.0, + "content": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "nition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 111, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 126 + ], + "score": 1.0, + "content": "Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric Xing. Harnessing deep neural", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 123, + 282, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 282, + 135 + ], + "score": 1.0, + "content": "networks with logic rules. In ACL, 2016.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 110, + 505, + 135 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 141, + 504, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 140, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 140, + 505, + 155 + ], + "score": 1.0, + "content": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 505, + 165 + ], + "score": 1.0, + "content": "reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 143, + 176 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 143, + 176 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 106, + 140, + 505, + 176 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 181, + 430, + 194 + ], + "lines": [ + { + "bbox": [ + 105, + 181, + 427, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 427, + 195 + ], + "score": 1.0, + "content": "Douglas Samuel Jones. Elementary information theory. Clarendon Press, 1979.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 181, + 427, + 195 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 200, + 473, + 212 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 475, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 475, + 214 + ], + "score": 1.0, + "content": "Diederik P Kingma and Jimmy Lei Ba. Adam: A method for stochastic optimization. 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 199, + 475, + 214 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 219, + 506, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 219, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 219, + 505, + 231 + ], + "score": 1.0, + "content": "Diederik P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 229, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 229, + 506, + 243 + ], + "score": 1.0, + "content": "learning with deep generative models. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 241, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 115, + 241, + 506, + 254 + ], + "score": 1.0, + "content": "and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 3581–", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 253, + 264, + 263 + ], + "spans": [ + { + "bbox": [ + 116, + 253, + 264, + 263 + ], + "score": 1.0, + "content": "3589. Curran Associates, Inc., 2014.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 106, + 219, + 506, + 263 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 270, + 504, + 293 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 283 + ], + "score": 1.0, + "content": "Doga Kisa, Guy Van den Broeck, Arthur Choi, and Adnan Darwiche. Probabilistic sentential deci-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 282, + 294, + 293 + ], + "spans": [ + { + "bbox": [ + 116, + 282, + 294, + 293 + ], + "score": 1.0, + "content": "sion diagrams. In Proceedings of KR, 2014.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 270, + 505, + 293 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 299, + 504, + 312 + ], + "lines": [ + { + "bbox": [ + 106, + 299, + 504, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 504, + 313 + ], + "score": 1.0, + "content": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15, + "bbox_fs": [ + 106, + 299, + 504, + 313 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 503, + 353 + ], + "lines": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classifcation with deep convo-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 329, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 329, + 505, + 343 + ], + "score": 1.0, + "content": "lutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.),", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 341, + 432, + 353 + ], + "spans": [ + { + "bbox": [ + 115, + 341, + 432, + 353 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems 25, pp. 1097–1105, 2012.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 318, + 505, + 353 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 359, + 504, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 358, + 504, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 504, + 372 + ], + "score": 1.0, + "content": "Pablo Marquez-Neila, Mathieu Salzmann, and Pascal Fua. Imposing hard constraints on deep net-´", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 370, + 414, + 382 + ], + "spans": [ + { + "bbox": [ + 115, + 370, + 414, + 382 + ], + "score": 1.0, + "content": "works: Promises and limitations. arXiv preprint arXiv:1706.02025, 2017.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 358, + 504, + 382 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 388, + 505, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 507, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 507, + 402 + ], + "score": 1.0, + "content": "Robert Mateescu and Rina Dechter. Mixed deterministic and probabilistic networks. Annals of", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 400, + 343, + 412 + ], + "spans": [ + { + "bbox": [ + 115, + 400, + 343, + 412 + ], + "score": 1.0, + "content": "mathematics and artificial intelligence, 54(1-3):3, 2008.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 387, + 507, + 412 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 418, + 505, + 441 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "Nicholas Mattei and Toby Walsh. Preflib: A library of preference data HTTP://PREFLIB.ORG. In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 428, + 227, + 441 + ], + "spans": [ + { + "bbox": [ + 115, + 428, + 227, + 441 + ], + "score": 1.0, + "content": "Proceedings of ADT, 2013.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 106, + 418, + 505, + 441 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 447, + 504, + 471 + ], + "lines": [ + { + "bbox": [ + 106, + 448, + 504, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 504, + 460 + ], + "score": 1.0, + "content": "Pasquale Minervini, Thomas Demeester, Tim Rocktaschel, and Sebastian Riedel. Adversarial sets ¨", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 459, + 435, + 471 + ], + "spans": [ + { + "bbox": [ + 115, + 459, + 435, + 471 + ], + "score": 1.0, + "content": "for regularising neural link predictors. arXiv preprint arXiv:1707.07596, 2017.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 448, + 504, + 471 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 477, + 504, + 500 + ], + "lines": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 489 + ], + "score": 1.0, + "content": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 489, + 355, + 501 + ], + "spans": [ + { + "bbox": [ + 115, + 489, + 355, + 501 + ], + "score": 1.0, + "content": "smoothing with virtual adversarial training. In ICLR, 2016.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 477, + 505, + 501 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 506, + 504, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Virtual adversarial", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 115, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "training: a regularization method for supervised and semi-supervised learning. ArXiv e-prints,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 528, + 144, + 541 + ], + "spans": [ + { + "bbox": [ + 115, + 528, + 144, + 541 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 106, + 507, + 505, + 541 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 547, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 107, + 547, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 107, + 547, + 505, + 561 + ], + "score": 1.0, + "content": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "In Proceedings of the 27th International Conference on International Conference on Machine", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 569, + 285, + 582 + ], + "spans": [ + { + "bbox": [ + 116, + 569, + 285, + 582 + ], + "score": 1.0, + "content": "Learning, pp. 807–814. Omnipress, 2010.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 107, + 547, + 505, + 582 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 587, + 504, + 611 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 505, + 601 + ], + "score": 1.0, + "content": "Jason Naradowsky and Sebastian Riedel. Modeling exclusion with a differentiable factor graph", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 599, + 465, + 611 + ], + "spans": [ + { + "bbox": [ + 116, + 599, + 465, + 611 + ], + "score": 1.0, + "content": "constraint. In International Conference on Machine Learning (Workshop Track), 2017.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 586, + 505, + 611 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 617, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Benjamin Roth, and Andrew McCallum. Compositional vector space models", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 629, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 115, + 629, + 505, + 641 + ], + "score": 1.0, + "content": "for knowledge base inference. In Proceedings of the 53rd Annual Meeting of the Association", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 114, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "for Computational Linguistics and the 7th International Joint Conference on Natural Language", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 650, + 245, + 662 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 245, + 662 + ], + "score": 1.0, + "content": "Processing, pp. 156–166, 2015.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5, + "bbox_fs": [ + 106, + 617, + 505, + 662 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 668, + 503, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural net-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 116, + 680, + 485, + 692 + ], + "spans": [ + { + "bbox": [ + 116, + 680, + 485, + 692 + ], + "score": 1.0, + "content": "works for graphs. In International Conference on Machine Learning, pp. 2014–2023, 2016.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 668, + 505, + 692 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 504, + 712 + ], + "score": 1.0, + "content": "Masaaki Nishino, Norihito Yasuda, Shin-ichi Minato, and Masaaki Nagata. Compiling graph sub-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 708, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 708, + 506, + 723 + ], + "score": 1.0, + "content": "structures into sentential decision diagrams. In Proceedings of the Thirty-First Conference on", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 720, + 263, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 263, + 733 + ], + "score": 1.0, + "content": "Artificial Intelligence (AAAI), 2017.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 697, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 77, + 506, + 512 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "for weakly supervised segmentation. In Proceedings of the IEEE International Conference on", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 104, + 278, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 104, + 278, + 117 + ], + "score": 1.0, + "content": "Computer Vision, pp. 1796–1804, 2015.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 121, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 505, + 137 + ], + "score": 1.0, + "content": "Nikolaos Pitelis, Chris Russell, and Lourdes Agapito. Semi-supervised learning using an unsuper-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 134, + 417, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 134, + 417, + 146 + ], + "score": 1.0, + "content": "vised atlas. In Proceedings of ECML-PKDD, pp. 565–580. Springer, 2014.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 152, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 504, + 164 + ], + "score": 1.0, + "content": "Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 506, + 177 + ], + "score": 1.0, + "content": "supervised learning with ladder networks. In Advances in Neural Information Processing Systems,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 207, + 186 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 207, + 186 + ], + "score": 1.0, + "content": "pp. 3546–3554, 2015.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 191, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 271, + 206 + ], + "score": 1.0, + "content": "Scott Reed and Nando De Freitas.", + "type": "text" + }, + { + "bbox": [ + 285, + 192, + 425, + 205 + ], + "score": 1.0, + "content": "Neural programmer-interpreters.", + "type": "text" + }, + { + "bbox": [ + 438, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "arXiv preprint", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 204, + 219, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 204, + 219, + 214 + ], + "score": 1.0, + "content": "arXiv:1511.06279, 2015.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "Sebastian Riedel, Matko Bosnjak, and Tim Rocktaschel. Programming with a differentiable forth ¨", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 232, + 286, + 244 + ], + "spans": [ + { + "bbox": [ + 116, + 232, + 286, + 244 + ], + "score": 1.0, + "content": "interpreter. CoRR, abs/1605.06640, 2016.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 249, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 505, + 264 + ], + "score": 1.0, + "content": "Tim Rocktaschel, Sameer Singh, and Sebastian Riedel. Injecting logical background knowledge ¨", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 262, + 434, + 275 + ], + "spans": [ + { + "bbox": [ + 116, + 262, + 434, + 275 + ], + "score": 1.0, + "content": "into embeddings for relation extraction. In HLT-NAACL, pp. 1119–1129, 2015.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 280, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 294 + ], + "score": 1.0, + "content": "Tian Sang, Paul Beame, and Henry A Kautz. Performing bayesian inference by weighted model", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 291, + 316, + 303 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 316, + 303 + ], + "score": 1.0, + "content": "counting. In AAAI, volume 5, pp. 475–481, 2005.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 308, + 504, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 504, + 322 + ], + "score": 1.0, + "content": "Yujia Shen, Arthur Choi, and Adnan Darwiche. A tractable probabilistic model for subset selection.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 321, + 486, + 333 + ], + "spans": [ + { + "bbox": [ + 116, + 321, + 486, + 333 + ], + "score": 1.0, + "content": "In Proceedings of the 33rd Conference on Uncertainty in Artificial Intelligence (UAI), 2017.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "David Smith and Vibhav Gogate. Loopy belief propagation in the presence of determinism. In", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 349, + 343, + 362 + ], + "spans": [ + { + "bbox": [ + 114, + 349, + 343, + 362 + ], + "score": 1.0, + "content": "Artificial Intelligence and Statistics, pp. 895–903, 2014.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "Ashwin Srinivasan, S Muggleton, and RD King. Comparing the use of background knowledge by", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 116, + 379, + 444, + 391 + ], + "spans": [ + { + "bbox": [ + 116, + 379, + 444, + 391 + ], + "score": 1.0, + "content": "inductive logic programming systems. In Proceedings of ILP, pp. 199–230, 1995.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 397, + 504, + 409 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 504, + 409 + ], + "score": 1.0, + "content": "Russell Stewart and Stefano Ermon. Label-free supervision of neural networks with physics and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 408, + 326, + 420 + ], + "spans": [ + { + "bbox": [ + 116, + 408, + 326, + 420 + ], + "score": 1.0, + "content": "domain knowledge. In AAAI, pp. 2576–2582, 2017.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 425, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 440 + ], + "score": 1.0, + "content": "Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 437, + 376, + 450 + ], + "spans": [ + { + "bbox": [ + 115, + 437, + 376, + 450 + ], + "score": 1.0, + "content": "deep graph embedding. arXiv preprint arXiv:1709.09994, 2017.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 466, + 214, + 478 + ], + "spans": [ + { + "bbox": [ + 115, + 466, + 214, + 478 + ], + "score": 1.0, + "content": "arXiv:1410.3916, 2014.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmark-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 496, + 276, + 508 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 276, + 508 + ], + "score": 1.0, + "content": "ing machine learning algorithms, 2017.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 526, + 378, + 540 + ], + "lines": [ + { + "bbox": [ + 105, + 525, + 379, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 379, + 542 + ], + "score": 1.0, + "content": "A AXIOMATIZATION OF SEMANTIC LOSS: DETAILS", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 106, + 551, + 434, + 578 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 433, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 433, + 564 + ], + "score": 1.0, + "content": "This appendix provides further details on our axiomatization of the semantic loss.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 565, + 364, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 364, + 578 + ], + "score": 1.0, + "content": "Proposition 5 (Non-Negativity). Semantic loss is non-negative.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 106, + 589, + 504, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 171, + 602 + ], + "score": 1.0, + "content": "Proof. Because", + "type": "text" + }, + { + "bbox": [ + 171, + 590, + 191, + 601 + ], + "score": 0.75, + "content": "\\alpha \\models", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 589, + 237, + 602 + ], + "score": 1.0, + "content": "true for all", + "type": "text" + }, + { + "bbox": [ + 237, + 591, + 245, + 600 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 589, + 392, + 602 + ], + "score": 1.0, + "content": ", the monotonicity axiom implies that", + "type": "text" + }, + { + "bbox": [ + 393, + 589, + 501, + 601 + ], + "score": 0.9, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } ) \\geq \\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 589, + 505, + 602 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 186, + 613 + ], + "score": 1.0, + "content": "By the truth axiom,", + "type": "text" + }, + { + "bbox": [ + 187, + 601, + 251, + 613 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 600, + 310, + 613 + ], + "score": 1.0, + "content": ", and therefore", + "type": "text" + }, + { + "bbox": [ + 311, + 600, + 364, + 613 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 600, + 434, + 613 + ], + "score": 1.0, + "content": "for all choices of", + "type": "text" + }, + { + "bbox": [ + 435, + 603, + 442, + 610 + ], + "score": 0.81, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 600, + 460, + 613 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 460, + 603, + 467, + 612 + ], + "score": 0.59, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 600, + 471, + 613 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 494, + 601, + 506, + 612 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 105, + 618, + 504, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 313, + 632 + ], + "score": 1.0, + "content": "Proposition 6 (Locality). Let α be a sentence over", + "type": "text" + }, + { + "bbox": [ + 313, + 619, + 323, + 628 + ], + "score": 0.43, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 617, + 440, + 632 + ], + "score": 1.0, + "content": "with probabilities p. For any", + "type": "text" + }, + { + "bbox": [ + 441, + 618, + 451, + 628 + ], + "score": 0.44, + "content": "\\mathbf { Y }", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 617, + 505, + 632 + ], + "score": 1.0, + "content": "disjoint from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 628, + 369, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 117, + 640 + ], + "score": 0.32, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 628, + 271, + 643 + ], + "score": 1.0, + "content": "with probabilities q, the semantic loss", + "type": "text" + }, + { + "bbox": [ + 271, + 629, + 365, + 641 + ], + "score": 0.91, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , [ \\mathsf { p q } ] ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 628, + 369, + 643 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 106, + 653, + 505, + 676 + ], + "lines": [ + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 398, + 664 + ], + "score": 1.0, + "content": "Proof. Follows from the additive independence and truth axioms. Set", + "type": "text" + }, + { + "bbox": [ + 398, + 653, + 441, + 664 + ], + "score": 0.67, + "content": "\\beta \\ = \\ t r u e", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 653, + 505, + 664 + ], + "score": 1.0, + "content": "in the additive", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 295, + 677 + ], + "score": 1.0, + "content": "independence axiom, and observe that this sets", + "type": "text" + }, + { + "bbox": [ + 296, + 664, + 348, + 676 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathsf { q } } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 664, + 461, + 677 + ], + "score": 1.0, + "content": "because of the truth axiom.", + "type": "text" + }, + { + "bbox": [ + 495, + 665, + 505, + 675 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 411, + 700 + ], + "score": 1.0, + "content": "Proof of Proposition 2. The monotonicity axiom specializes to say that if", + "type": "text" + }, + { + "bbox": [ + 412, + 688, + 444, + 699 + ], + "score": 0.88, + "content": "{ \\textbf { x } } | = \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 687, + 506, + 700 + ], + "score": 1.0, + "content": ", we have that", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 207, + 711 + ], + "score": 0.88, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathsf { p } ) \\ \\geq \\ \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 698, + 271, + 712 + ], + "score": 1.0, + "content": ". By choosing", + "type": "text" + }, + { + "bbox": [ + 271, + 701, + 278, + 710 + ], + "score": 0.53, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 698, + 304, + 712 + ], + "score": 1.0, + "content": "to be", + "type": "text" + }, + { + "bbox": [ + 304, + 701, + 312, + 709 + ], + "score": 0.51, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 698, + 368, + 712 + ], + "score": 1.0, + "content": ", this implies", + "type": "text" + }, + { + "bbox": [ + 369, + 699, + 457, + 711 + ], + "score": 0.9, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathbf { x } ) \\ \\geq \\ \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ". From the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 708, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 171, + 722 + ], + "score": 1.0, + "content": "identity axiom,", + "type": "text" + }, + { + "bbox": [ + 172, + 710, + 229, + 722 + ], + "score": 0.9, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( { \\bf x } , { \\bf x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 708, + 292, + 722 + ], + "score": 1.0, + "content": ", and therefore", + "type": "text" + }, + { + "bbox": [ + 293, + 710, + 350, + 722 + ], + "score": 0.93, + "content": "0 \\geq \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 708, + 506, + 722 + ], + "score": 1.0, + "content": ". Proposition 5 bounds the loss from", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 144, + 733 + ], + "score": 1.0, + "content": "below as", + "type": "text" + }, + { + "bbox": [ + 144, + 721, + 198, + 732 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } ) \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 720, + 203, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 494, + 721, + 505, + 731 + ], + "score": 1.0, + "content": "□", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 77, + 506, + 512 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "for weakly supervised segmentation. In Proceedings of the IEEE International Conference on", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 104, + 278, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 104, + 278, + 117 + ], + "score": 1.0, + "content": "Computer Vision, pp. 1796–1804, 2015.", + "type": "text" + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 121, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 104, + 121, + 505, + 137 + ], + "score": 1.0, + "content": "Nikolaos Pitelis, Chris Russell, and Lourdes Agapito. Semi-supervised learning using an unsuper-", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 134, + 417, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 134, + 417, + 146 + ], + "score": 1.0, + "content": "vised atlas. In Proceedings of ECML-PKDD, pp. 565–580. Springer, 2014.", + "type": "text" + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 152, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 504, + 164 + ], + "score": 1.0, + "content": "Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 162, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 506, + 177 + ], + "score": 1.0, + "content": "supervised learning with ladder networks. In Advances in Neural Information Processing Systems,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 174, + 207, + 186 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 207, + 186 + ], + "score": 1.0, + "content": "pp. 3546–3554, 2015.", + "type": "text" + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 191, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 271, + 206 + ], + "score": 1.0, + "content": "Scott Reed and Nando De Freitas.", + "type": "text" + }, + { + "bbox": [ + 285, + 192, + 425, + 205 + ], + "score": 1.0, + "content": "Neural programmer-interpreters.", + "type": "text" + }, + { + "bbox": [ + 438, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "arXiv preprint", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 204, + 219, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 204, + 219, + 214 + ], + "score": 1.0, + "content": "arXiv:1511.06279, 2015.", + "type": "text" + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "Sebastian Riedel, Matko Bosnjak, and Tim Rocktaschel. Programming with a differentiable forth ¨", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 232, + 286, + 244 + ], + "spans": [ + { + "bbox": [ + 116, + 232, + 286, + 244 + ], + "score": 1.0, + "content": "interpreter. CoRR, abs/1605.06640, 2016.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 249, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 249, + 505, + 264 + ], + "score": 1.0, + "content": "Tim Rocktaschel, Sameer Singh, and Sebastian Riedel. Injecting logical background knowledge ¨", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 262, + 434, + 275 + ], + "spans": [ + { + "bbox": [ + 116, + 262, + 434, + 275 + ], + "score": 1.0, + "content": "into embeddings for relation extraction. In HLT-NAACL, pp. 1119–1129, 2015.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 280, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 294 + ], + "score": 1.0, + "content": "Tian Sang, Paul Beame, and Henry A Kautz. Performing bayesian inference by weighted model", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 291, + 316, + 303 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 316, + 303 + ], + "score": 1.0, + "content": "counting. In AAAI, volume 5, pp. 475–481, 2005.", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 308, + 504, + 322 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 504, + 322 + ], + "score": 1.0, + "content": "Yujia Shen, Arthur Choi, and Adnan Darwiche. A tractable probabilistic model for subset selection.", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 321, + 486, + 333 + ], + "spans": [ + { + "bbox": [ + 116, + 321, + 486, + 333 + ], + "score": 1.0, + "content": "In Proceedings of the 33rd Conference on Uncertainty in Artificial Intelligence (UAI), 2017.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "David Smith and Vibhav Gogate. Loopy belief propagation in the presence of determinism. In", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 349, + 343, + 362 + ], + "spans": [ + { + "bbox": [ + 114, + 349, + 343, + 362 + ], + "score": 1.0, + "content": "Artificial Intelligence and Statistics, pp. 895–903, 2014.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "Ashwin Srinivasan, S Muggleton, and RD King. Comparing the use of background knowledge by", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 379, + 444, + 391 + ], + "spans": [ + { + "bbox": [ + 116, + 379, + 444, + 391 + ], + "score": 1.0, + "content": "inductive logic programming systems. In Proceedings of ILP, pp. 199–230, 1995.", + "type": "text" + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 397, + 504, + 409 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 504, + 409 + ], + "score": 1.0, + "content": "Russell Stewart and Stefano Ermon. Label-free supervision of neural networks with physics and", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 408, + 326, + 420 + ], + "spans": [ + { + "bbox": [ + 116, + 408, + 326, + 420 + ], + "score": 1.0, + "content": "domain knowledge. In AAAI, pp. 2576–2582, 2017.", + "type": "text" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 425, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 440 + ], + "score": 1.0, + "content": "Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 437, + 376, + 450 + ], + "spans": [ + { + "bbox": [ + 115, + 437, + 376, + 450 + ], + "score": 1.0, + "content": "deep graph embedding. arXiv preprint arXiv:1709.09994, 2017.", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 469 + ], + "score": 1.0, + "content": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 466, + 214, + 478 + ], + "spans": [ + { + "bbox": [ + 115, + 466, + 214, + 478 + ], + "score": 1.0, + "content": "arXiv:1410.3916, 2014.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 484, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 498 + ], + "score": 1.0, + "content": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmark-", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 496, + 276, + 508 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 276, + 508 + ], + "score": 1.0, + "content": "ing machine learning algorithms, 2017.", + "type": "text" + } + ], + "index": 29, + "is_list_end_line": true + } + ], + "index": 14.5, + "bbox_fs": [ + 104, + 83, + 506, + 508 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 526, + 378, + 540 + ], + "lines": [ + { + "bbox": [ + 105, + 525, + 379, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 379, + 542 + ], + "score": 1.0, + "content": "A AXIOMATIZATION OF SEMANTIC LOSS: DETAILS", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 525, + 379, + 542 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 551, + 434, + 578 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 433, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 433, + 564 + ], + "score": 1.0, + "content": "This appendix provides further details on our axiomatization of the semantic loss.", + "type": "text" + } + ], + "index": 31, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 565, + 364, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 364, + 578 + ], + "score": 1.0, + "content": "Proposition 5 (Non-Negativity). Semantic loss is non-negative.", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 551, + 433, + 578 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 589, + 504, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 171, + 602 + ], + "score": 1.0, + "content": "Proof. Because", + "type": "text" + }, + { + "bbox": [ + 171, + 590, + 191, + 601 + ], + "score": 0.75, + "content": "\\alpha \\models", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 589, + 237, + 602 + ], + "score": 1.0, + "content": "true for all", + "type": "text" + }, + { + "bbox": [ + 237, + 591, + 245, + 600 + ], + "score": 0.75, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 589, + 392, + 602 + ], + "score": 1.0, + "content": ", the monotonicity axiom implies that", + "type": "text" + }, + { + "bbox": [ + 393, + 589, + 501, + 601 + ], + "score": 0.9, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } ) \\geq \\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 589, + 505, + 602 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 186, + 613 + ], + "score": 1.0, + "content": "By the truth axiom,", + "type": "text" + }, + { + "bbox": [ + 187, + 601, + 251, + 613 + ], + "score": 0.91, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( t r u e , \\mathsf { p } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 600, + 310, + 613 + ], + "score": 1.0, + "content": ", and therefore", + "type": "text" + }, + { + "bbox": [ + 311, + 600, + 364, + 613 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 600, + 434, + 613 + ], + "score": 1.0, + "content": "for all choices of", + "type": "text" + }, + { + "bbox": [ + 435, + 603, + 442, + 610 + ], + "score": 0.81, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 443, + 600, + 460, + 613 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 460, + 603, + 467, + 612 + ], + "score": 0.59, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 467, + 600, + 471, + 613 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 494, + 601, + 506, + 612 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5, + "bbox_fs": [ + 106, + 589, + 506, + 613 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 618, + 504, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 313, + 632 + ], + "score": 1.0, + "content": "Proposition 6 (Locality). Let α be a sentence over", + "type": "text" + }, + { + "bbox": [ + 313, + 619, + 323, + 628 + ], + "score": 0.43, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 617, + 440, + 632 + ], + "score": 1.0, + "content": "with probabilities p. For any", + "type": "text" + }, + { + "bbox": [ + 441, + 618, + 451, + 628 + ], + "score": 0.44, + "content": "\\mathbf { Y }", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 617, + 505, + 632 + ], + "score": 1.0, + "content": "disjoint from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 628, + 369, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 630, + 117, + 640 + ], + "score": 0.32, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 628, + 271, + 643 + ], + "score": 1.0, + "content": "with probabilities q, the semantic loss", + "type": "text" + }, + { + "bbox": [ + 271, + 629, + 365, + 641 + ], + "score": 0.91, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , [ \\mathsf { p q } ] ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 628, + 369, + 643 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 617, + 505, + 643 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 653, + 505, + 676 + ], + "lines": [ + { + "bbox": [ + 106, + 653, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 398, + 664 + ], + "score": 1.0, + "content": "Proof. Follows from the additive independence and truth axioms. Set", + "type": "text" + }, + { + "bbox": [ + 398, + 653, + 441, + 664 + ], + "score": 0.67, + "content": "\\beta \\ = \\ t r u e", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 653, + 505, + 664 + ], + "score": 1.0, + "content": "in the additive", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 295, + 677 + ], + "score": 1.0, + "content": "independence axiom, and observe that this sets", + "type": "text" + }, + { + "bbox": [ + 296, + 664, + 348, + 676 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\beta , { \\mathsf { q } } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 664, + 461, + 677 + ], + "score": 1.0, + "content": "because of the truth axiom.", + "type": "text" + }, + { + "bbox": [ + 495, + 665, + 505, + 675 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5, + "bbox_fs": [ + 106, + 653, + 505, + 677 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 411, + 700 + ], + "score": 1.0, + "content": "Proof of Proposition 2. The monotonicity axiom specializes to say that if", + "type": "text" + }, + { + "bbox": [ + 412, + 688, + 444, + 699 + ], + "score": 0.88, + "content": "{ \\textbf { x } } | = \\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 687, + 506, + 700 + ], + "score": 1.0, + "content": ", we have that", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 207, + 711 + ], + "score": 0.88, + "content": "\\forall \\mathsf { p } , \\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathsf { p } ) \\ \\geq \\ \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 698, + 271, + 712 + ], + "score": 1.0, + "content": ". By choosing", + "type": "text" + }, + { + "bbox": [ + 271, + 701, + 278, + 710 + ], + "score": 0.53, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 698, + 304, + 712 + ], + "score": 1.0, + "content": "to be", + "type": "text" + }, + { + "bbox": [ + 304, + 701, + 312, + 709 + ], + "score": 0.51, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 698, + 368, + 712 + ], + "score": 1.0, + "content": ", this implies", + "type": "text" + }, + { + "bbox": [ + 369, + 699, + 457, + 711 + ], + "score": 0.9, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\mathbf { x } , \\mathbf { x } ) \\ \\geq \\ \\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ". From the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 708, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 171, + 722 + ], + "score": 1.0, + "content": "identity axiom,", + "type": "text" + }, + { + "bbox": [ + 172, + 710, + 229, + 722 + ], + "score": 0.9, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( { \\bf x } , { \\bf x } ) = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 708, + 292, + 722 + ], + "score": 1.0, + "content": ", and therefore", + "type": "text" + }, + { + "bbox": [ + 293, + 710, + 350, + 722 + ], + "score": 0.93, + "content": "0 \\geq \\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } )", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 708, + 506, + 722 + ], + "score": 1.0, + "content": ". Proposition 5 bounds the loss from", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 144, + 733 + ], + "score": 1.0, + "content": "below as", + "type": "text" + }, + { + "bbox": [ + 144, + 721, + 198, + 732 + ], + "score": 0.92, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , \\mathbf { x } ) \\geq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 720, + 203, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 494, + 721, + 505, + 731 + ], + "score": 1.0, + "content": "□", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 687, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 252, + 96 + ], + "score": 1.0, + "content": "Axiom 7 (Value Symmetry). For all", + "type": "text" + }, + { + "bbox": [ + 252, + 84, + 258, + 94 + ], + "score": 0.53, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 81, + 275, + 96 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 276, + 84, + 283, + 93 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 81, + 338, + 96 + ], + "score": 1.0, + "content": ", we have that", + "type": "text" + }, + { + "bbox": [ + 338, + 82, + 434, + 95 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) = \\mathrm { L } ^ { \\mathrm { s } } ( { \\bar { \\alpha } } , 1 - { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 81, + 461, + 96 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 461, + 84, + 469, + 92 + ], + "score": 0.77, + "content": "\\bar { \\alpha }", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "replaces", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 247, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 175, + 106 + ], + "score": 1.0, + "content": "every variable in", + "type": "text" + }, + { + "bbox": [ + 175, + 95, + 183, + 104 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 94, + 247, + 106 + ], + "score": 1.0, + "content": "by its negation.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 109, + 505, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 108, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 108, + 251, + 122 + ], + "score": 1.0, + "content": "Axiom 8 (Variable Symmetry). Let", + "type": "text" + }, + { + "bbox": [ + 252, + 111, + 259, + 119 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 108, + 336, + 122 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 336, + 109, + 346, + 119 + ], + "score": 0.52, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 108, + 420, + 122 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 420, + 110, + 426, + 120 + ], + "score": 0.41, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 108, + 446, + 122 + ], + "score": 1.0, + "content": ". Let", + "type": "text" + }, + { + "bbox": [ + 446, + 111, + 454, + 119 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 454, + 108, + 505, + 122 + ], + "score": 1.0, + "content": "be a permu-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 197, + 132 + ], + "score": 1.0, + "content": "tation of the variables", + "type": "text" + }, + { + "bbox": [ + 197, + 120, + 207, + 130 + ], + "score": 0.37, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 119, + 224, + 132 + ], + "score": 1.0, + "content": ", let", + "type": "text" + }, + { + "bbox": [ + 225, + 120, + 246, + 131 + ], + "score": 0.92, + "content": "\\pi ( \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 119, + 441, + 132 + ], + "score": 1.0, + "content": "be the sentence obtained by replacing variables", + "type": "text" + }, + { + "bbox": [ + 442, + 122, + 449, + 129 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 119, + 463, + 132 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 463, + 120, + 483, + 131 + ], + "score": 0.9, + "content": "\\pi ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 119, + 505, + 132 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 499, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 119, + 145 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 119, + 131, + 139, + 143 + ], + "score": 0.89, + "content": "\\pi ( { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 129, + 385, + 145 + ], + "score": 1.0, + "content": "be the corresponding permuted vector of probabilities. Then,", + "type": "text" + }, + { + "bbox": [ + 385, + 131, + 494, + 143 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\pi ( \\alpha ) , \\pi ( { \\mathsf { p } } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 129, + 499, + 145 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 147, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 106, + 147, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 161 + ], + "score": 1.0, + "content": "The value and variable symmetry axioms together imply the equality of the multiplicative constants", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 295, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 295, + 171 + ], + "score": 1.0, + "content": "in the label-literal duality axiom for all literals.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 105, + 173, + 504, + 196 + ], + "lines": [ + { + "bbox": [ + 105, + 172, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 279, + 188 + ], + "score": 1.0, + "content": "Lemma 7. There exists a single constant", + "type": "text" + }, + { + "bbox": [ + 279, + 174, + 289, + 184 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 172, + 331, + 188 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 331, + 174, + 428, + 186 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( X , p ) = - K \\log ( p )", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 172, + 448, + 188 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 448, + 174, + 505, + 186 + ], + "score": 0.9, + "content": "\\operatorname { L } ^ { s } ( \\lnot X , p ) =", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 184, + 239, + 198 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 169, + 197 + ], + "score": 0.91, + "content": "- K \\log ( 1 - p )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 184, + 228, + 198 + ], + "score": 1.0, + "content": "for any literal", + "type": "text" + }, + { + "bbox": [ + 228, + 187, + 235, + 195 + ], + "score": 0.68, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 184, + 239, + 198 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 256, + 224 + ], + "score": 1.0, + "content": "Proof. Value symmetry implies that", + "type": "text" + }, + { + "bbox": [ + 257, + 211, + 376, + 223 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( X _ { i } , \\mathfrak { p } ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\lnot X _ { i } , 1 - \\mathfrak { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 211, + 505, + 224 + ], + "score": 1.0, + "content": ". Using label-literal correspon-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 182, + 235 + ], + "score": 1.0, + "content": "dence, this implies", + "type": "text" + }, + { + "bbox": [ + 182, + 222, + 315, + 234 + ], + "score": 0.88, + "content": "K _ { 1 } \\log ( p _ { i } ) = K _ { 2 } \\log ( 1 - ( 1 - p _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 221, + 441, + 235 + ], + "score": 1.0, + "content": "for the multiplicative constants", + "type": "text" + }, + { + "bbox": [ + 441, + 223, + 455, + 233 + ], + "score": 0.89, + "content": "K _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 221, + 472, + 235 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 473, + 223, + 487, + 233 + ], + "score": 0.89, + "content": "K _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 233, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 506, + 245 + ], + "score": 1.0, + "content": "are left unspecified by that axiom. This implies that the constants are identical. A similar argument", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 479, + 257 + ], + "score": 1.0, + "content": "based on variable symmetry proves equality between the multiplicative constants for different", + "type": "text" + }, + { + "bbox": [ + 479, + 245, + 483, + 254 + ], + "score": 0.72, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 244, + 506, + 257 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 270, + 504, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 504, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 217, + 282 + ], + "score": 1.0, + "content": "Proof of Lemma 3. A state", + "type": "text" + }, + { + "bbox": [ + 217, + 272, + 226, + 280 + ], + "score": 0.61, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 270, + 504, + 282 + ], + "score": 1.0, + "content": "is a conjunction of independent literals, and therefore subject to the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 444, + 293 + ], + "score": 1.0, + "content": "additive independence axiom. Each literal’s loss in this sum is defined by Lemma 7.", + "type": "text" + }, + { + "bbox": [ + 495, + 282, + 505, + 291 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 307, + 504, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "The following and final axiom requires that the semantic loss is proportionate to the logarithm of a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 317, + 338, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 338, + 331 + ], + "score": 1.0, + "content": "function that is additive for mutually exclusive sentences.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 271, + 345 + ], + "score": 1.0, + "content": "Axiom 9 (Exponential Additivity). Let", + "type": "text" + }, + { + "bbox": [ + 272, + 335, + 280, + 343 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 332, + 299, + 345 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 300, + 334, + 308, + 344 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 332, + 466, + 345 + ], + "score": 1.0, + "content": "be mutually exclusive sentences (i.e.,", + "type": "text" + }, + { + "bbox": [ + 467, + 334, + 493, + 345 + ], + "score": 0.91, + "content": "\\alpha \\wedge \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 332, + 505, + 345 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 195, + 358 + ], + "score": 1.0, + "content": "unsatisfiable), and let", + "type": "text" + }, + { + "bbox": [ + 195, + 344, + 299, + 357 + ], + "score": 0.87, + "content": "f ^ { s } ( K , \\alpha , { \\mathsf { p } } ) = K ^ { - \\mathtt { L } ^ { \\mathtt { s } } ( \\alpha , { \\mathsf { p } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 342, + 455, + 358 + ], + "score": 1.0, + "content": ". Then, there exists a positive constant", + "type": "text" + }, + { + "bbox": [ + 455, + 345, + 465, + 355 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 342, + 506, + 358 + ], + "score": 1.0, + "content": "such that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 355, + 296, + 369 + ], + "spans": [ + { + "bbox": [ + 107, + 356, + 291, + 368 + ], + "score": 0.88, + "content": "f ^ { s } ( K , \\alpha \\vee \\beta , \\mathsf { p } ) = f ^ { s } ( K , \\alpha , \\mathsf { p } ) + f ^ { s } ( K , \\beta , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 355, + 296, + 369 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 381, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 298, + 394 + ], + "score": 1.0, + "content": "Proof of Theorem 4. The truth axiom states that", + "type": "text" + }, + { + "bbox": [ + 298, + 382, + 311, + 393 + ], + "score": 0.5, + "content": "\\forall \\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 382, + 392, + 394 + ], + "score": 0.81, + "content": ", f ^ { s } ( K , t r u e , \\mathfrak { p } ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 381, + 491, + 394 + ], + "score": 1.0, + "content": "for all positive constants", + "type": "text" + }, + { + "bbox": [ + 491, + 383, + 501, + 392 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 381, + 505, + 394 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 392, + 504, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 459, + 407 + ], + "score": 1.0, + "content": "This is the first Kolmogorov axiom of probability. The second Kolmogorov axiom for", + "type": "text" + }, + { + "bbox": [ + 460, + 393, + 504, + 405 + ], + "score": 0.92, + "content": "f ^ { s } ( K , . , { \\mathsf { p } } )", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "score": 1.0, + "content": "follows from the additive independence axiom of semantic loss. The third Kolmogorov axiom", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "score": 1.0, + "content": "(for the finite discrete case) is given by the exponential additivity axiom of semantic loss. Hence,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 425, + 507, + 439 + ], + "spans": [ + { + "bbox": [ + 107, + 426, + 151, + 438 + ], + "score": 0.92, + "content": "f ^ { s } ( K , . , { \\mathsf { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 425, + 344, + 439 + ], + "score": 1.0, + "content": "is a probability distribution for some choice of", + "type": "text" + }, + { + "bbox": [ + 344, + 426, + 354, + 436 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 425, + 507, + 439 + ], + "score": 1.0, + "content": ", which implies the definition up to a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 437, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 201, + 448 + ], + "score": 1.0, + "content": "multiplicative constant.", + "type": "text" + }, + { + "bbox": [ + 494, + 437, + 506, + 448 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "title", + "bbox": [ + 106, + 465, + 485, + 478 + ], + "lines": [ + { + "bbox": [ + 104, + 464, + 488, + 479 + ], + "spans": [ + { + "bbox": [ + 104, + 464, + 488, + 479 + ], + "score": 1.0, + "content": "B SPECIFICATION OF THE CONVOLUTIONAL NEURAL NETWORK MODEL", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 490, + 505, + 546 + ], + "lines": [ + { + "bbox": [ + 107, + 491, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 107, + 491, + 505, + 501 + ], + "score": 1.0, + "content": "Table 6 shows the slight architectural difference between the CNN used in ladder nets and ours. The", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "major difference lies in the choice of ReLu. Note we add standard padded cropping to preprocess", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "images and an additional fully connected layer at the end of the model, neither is used in ladder nets.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "We only make those slight modification so that the baseline performance reported by Rasmus et al.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 534, + 213, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 213, + 547 + ], + "score": 1.0, + "content": "(2015) can be reproduced.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "title", + "bbox": [ + 107, + 562, + 324, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 561, + 325, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 325, + 577 + ], + "score": 1.0, + "content": "C HYPER-PARAMETER TUNING DETAILS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "Validation sets are used for tuning the weight associated with semantic loss, the only hyper-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "parameter that causes noticeable difference in performance for our method. For our semi-supervised", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 338, + 622 + ], + "score": 1.0, + "content": "classification experiments, we perform a grid search over", + "type": "text" + }, + { + "bbox": [ + 338, + 610, + 460, + 622 + ], + "score": 0.88, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "to find the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "optimal value. Empirically, 0.005 always gives the best or nearly the best results and we report its", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 632, + 213, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 213, + 644 + ], + "score": 1.0, + "content": "results on all experiments.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "For the FASHION dataset specifically, because MNIST and FASHION share the same image size", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "and structure, methods developed in MNIST should be able to directly perform on FASHION with-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "out heavy modifications. Because of this, we use the same hyper-parameters when evaluating our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "score": 1.0, + "content": "method. However, for the sake of fairness, we subject ladder nets to a small-scale parameter tuning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 693, + 267, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 267, + 705 + ], + "score": 1.0, + "content": "in case its performance is more volatile.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "For the grids experiment, the only hyper parameter that needed to be tuned was again the weight", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 278, + 733 + ], + "score": 1.0, + "content": "given to semantic loss, which after trying", + "type": "text" + }, + { + "bbox": [ + 278, + 720, + 426, + 732 + ], + "score": 0.87, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 , 0 . 5 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "was selected to be", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 252, + 96 + ], + "score": 1.0, + "content": "Axiom 7 (Value Symmetry). For all", + "type": "text" + }, + { + "bbox": [ + 252, + 84, + 258, + 94 + ], + "score": 0.53, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 81, + 275, + 96 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 276, + 84, + 283, + 93 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 81, + 338, + 96 + ], + "score": 1.0, + "content": ", we have that", + "type": "text" + }, + { + "bbox": [ + 338, + 82, + 434, + 95 + ], + "score": 0.93, + "content": "\\mathrm { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathfrak { p } } ) = \\mathrm { L } ^ { \\mathrm { s } } ( { \\bar { \\alpha } } , 1 - { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 81, + 461, + 96 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 461, + 84, + 469, + 92 + ], + "score": 0.77, + "content": "\\bar { \\alpha }", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "replaces", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 247, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 175, + 106 + ], + "score": 1.0, + "content": "every variable in", + "type": "text" + }, + { + "bbox": [ + 175, + 95, + 183, + 104 + ], + "score": 0.76, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 94, + 247, + 106 + ], + "score": 1.0, + "content": "by its negation.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 109, + 505, + 142 + ], + "lines": [ + { + "bbox": [ + 106, + 108, + 505, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 108, + 251, + 122 + ], + "score": 1.0, + "content": "Axiom 8 (Variable Symmetry). Let", + "type": "text" + }, + { + "bbox": [ + 252, + 111, + 259, + 119 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 108, + 336, + 122 + ], + "score": 1.0, + "content": "be a sentence over", + "type": "text" + }, + { + "bbox": [ + 336, + 109, + 346, + 119 + ], + "score": 0.52, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 108, + 420, + 122 + ], + "score": 1.0, + "content": "with probabilities", + "type": "text" + }, + { + "bbox": [ + 420, + 110, + 426, + 120 + ], + "score": 0.41, + "content": "\\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 108, + 446, + 122 + ], + "score": 1.0, + "content": ". Let", + "type": "text" + }, + { + "bbox": [ + 446, + 111, + 454, + 119 + ], + "score": 0.78, + "content": "\\pi", + "type": "inline_equation" + }, + { + "bbox": [ + 454, + 108, + 505, + 122 + ], + "score": 1.0, + "content": "be a permu-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 197, + 132 + ], + "score": 1.0, + "content": "tation of the variables", + "type": "text" + }, + { + "bbox": [ + 197, + 120, + 207, + 130 + ], + "score": 0.37, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 119, + 224, + 132 + ], + "score": 1.0, + "content": ", let", + "type": "text" + }, + { + "bbox": [ + 225, + 120, + 246, + 131 + ], + "score": 0.92, + "content": "\\pi ( \\alpha )", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 119, + 441, + 132 + ], + "score": 1.0, + "content": "be the sentence obtained by replacing variables", + "type": "text" + }, + { + "bbox": [ + 442, + 122, + 449, + 129 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 119, + 463, + 132 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 463, + 120, + 483, + 131 + ], + "score": 0.9, + "content": "\\pi ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 119, + 505, + 132 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 129, + 499, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 119, + 145 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 119, + 131, + 139, + 143 + ], + "score": 0.89, + "content": "\\pi ( { \\mathfrak { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 129, + 385, + 145 + ], + "score": 1.0, + "content": "be the corresponding permuted vector of probabilities. Then,", + "type": "text" + }, + { + "bbox": [ + 385, + 131, + 494, + 143 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( \\alpha , { \\mathsf { p } } ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\pi ( \\alpha ) , \\pi ( { \\mathsf { p } } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 129, + 499, + 145 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 108, + 505, + 145 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 147, + 504, + 170 + ], + "lines": [ + { + "bbox": [ + 106, + 147, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 161 + ], + "score": 1.0, + "content": "The value and variable symmetry axioms together imply the equality of the multiplicative constants", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 295, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 295, + 171 + ], + "score": 1.0, + "content": "in the label-literal duality axiom for all literals.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 106, + 147, + 505, + 171 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 173, + 504, + 196 + ], + "lines": [ + { + "bbox": [ + 105, + 172, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 172, + 279, + 188 + ], + "score": 1.0, + "content": "Lemma 7. There exists a single constant", + "type": "text" + }, + { + "bbox": [ + 279, + 174, + 289, + 184 + ], + "score": 0.78, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 172, + 331, + 188 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 331, + 174, + 428, + 186 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( X , p ) = - K \\log ( p )", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 172, + 448, + 188 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 448, + 174, + 505, + 186 + ], + "score": 0.9, + "content": "\\operatorname { L } ^ { s } ( \\lnot X , p ) =", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 184, + 239, + 198 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 169, + 197 + ], + "score": 0.91, + "content": "- K \\log ( 1 - p )", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 184, + 228, + 198 + ], + "score": 1.0, + "content": "for any literal", + "type": "text" + }, + { + "bbox": [ + 228, + 187, + 235, + 195 + ], + "score": 0.68, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 184, + 239, + 198 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 172, + 505, + 198 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 210, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 211, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 256, + 224 + ], + "score": 1.0, + "content": "Proof. Value symmetry implies that", + "type": "text" + }, + { + "bbox": [ + 257, + 211, + 376, + 223 + ], + "score": 0.92, + "content": "\\operatorname { L } ^ { \\mathrm { s } } ( X _ { i } , \\mathfrak { p } ) = \\operatorname { L } ^ { \\mathrm { s } } ( \\lnot X _ { i } , 1 - \\mathfrak { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 211, + 505, + 224 + ], + "score": 1.0, + "content": ". Using label-literal correspon-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 221, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 182, + 235 + ], + "score": 1.0, + "content": "dence, this implies", + "type": "text" + }, + { + "bbox": [ + 182, + 222, + 315, + 234 + ], + "score": 0.88, + "content": "K _ { 1 } \\log ( p _ { i } ) = K _ { 2 } \\log ( 1 - ( 1 - p _ { i } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 221, + 441, + 235 + ], + "score": 1.0, + "content": "for the multiplicative constants", + "type": "text" + }, + { + "bbox": [ + 441, + 223, + 455, + 233 + ], + "score": 0.89, + "content": "K _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 455, + 221, + 472, + 235 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 473, + 223, + 487, + 233 + ], + "score": 0.89, + "content": "K _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 221, + 505, + 235 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 233, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 506, + 245 + ], + "score": 1.0, + "content": "are left unspecified by that axiom. This implies that the constants are identical. A similar argument", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 479, + 257 + ], + "score": 1.0, + "content": "based on variable symmetry proves equality between the multiplicative constants for different", + "type": "text" + }, + { + "bbox": [ + 479, + 245, + 483, + 254 + ], + "score": 0.72, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 244, + 506, + 257 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 211, + 506, + 257 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 270, + 504, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 504, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 217, + 282 + ], + "score": 1.0, + "content": "Proof of Lemma 3. A state", + "type": "text" + }, + { + "bbox": [ + 217, + 272, + 226, + 280 + ], + "score": 0.61, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 270, + 504, + 282 + ], + "score": 1.0, + "content": "is a conjunction of independent literals, and therefore subject to the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 280, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 444, + 293 + ], + "score": 1.0, + "content": "additive independence axiom. Each literal’s loss in this sum is defined by Lemma 7.", + "type": "text" + }, + { + "bbox": [ + 495, + 282, + 505, + 291 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 270, + 505, + 293 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 307, + 504, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 306, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 505, + 319 + ], + "score": 1.0, + "content": "The following and final axiom requires that the semantic loss is proportionate to the logarithm of a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 317, + 338, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 338, + 331 + ], + "score": 1.0, + "content": "function that is additive for mutually exclusive sentences.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 306, + 505, + 331 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 368 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 271, + 345 + ], + "score": 1.0, + "content": "Axiom 9 (Exponential Additivity). Let", + "type": "text" + }, + { + "bbox": [ + 272, + 335, + 280, + 343 + ], + "score": 0.79, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 332, + 299, + 345 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 300, + 334, + 308, + 344 + ], + "score": 0.83, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 332, + 466, + 345 + ], + "score": 1.0, + "content": "be mutually exclusive sentences (i.e.,", + "type": "text" + }, + { + "bbox": [ + 467, + 334, + 493, + 345 + ], + "score": 0.91, + "content": "\\alpha \\wedge \\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 332, + 505, + 345 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 195, + 358 + ], + "score": 1.0, + "content": "unsatisfiable), and let", + "type": "text" + }, + { + "bbox": [ + 195, + 344, + 299, + 357 + ], + "score": 0.87, + "content": "f ^ { s } ( K , \\alpha , { \\mathsf { p } } ) = K ^ { - \\mathtt { L } ^ { \\mathtt { s } } ( \\alpha , { \\mathsf { p } } ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 342, + 455, + 358 + ], + "score": 1.0, + "content": ". Then, there exists a positive constant", + "type": "text" + }, + { + "bbox": [ + 455, + 345, + 465, + 355 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 342, + 506, + 358 + ], + "score": 1.0, + "content": "such that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 355, + 296, + 369 + ], + "spans": [ + { + "bbox": [ + 107, + 356, + 291, + 368 + ], + "score": 0.88, + "content": "f ^ { s } ( K , \\alpha \\vee \\beta , \\mathsf { p } ) = f ^ { s } ( K , \\alpha , \\mathsf { p } ) + f ^ { s } ( K , \\beta , \\mathsf { p } )", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 355, + 296, + 369 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 332, + 506, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 381, + 505, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 298, + 394 + ], + "score": 1.0, + "content": "Proof of Theorem 4. The truth axiom states that", + "type": "text" + }, + { + "bbox": [ + 298, + 382, + 311, + 393 + ], + "score": 0.5, + "content": "\\forall \\mathsf { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 382, + 392, + 394 + ], + "score": 0.81, + "content": ", f ^ { s } ( K , t r u e , \\mathfrak { p } ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 381, + 491, + 394 + ], + "score": 1.0, + "content": "for all positive constants", + "type": "text" + }, + { + "bbox": [ + 491, + 383, + 501, + 392 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 381, + 505, + 394 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 392, + 504, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 459, + 407 + ], + "score": 1.0, + "content": "This is the first Kolmogorov axiom of probability. The second Kolmogorov axiom for", + "type": "text" + }, + { + "bbox": [ + 460, + 393, + 504, + 405 + ], + "score": 0.92, + "content": "f ^ { s } ( K , . , { \\mathsf { p } } )", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 417 + ], + "score": 1.0, + "content": "follows from the additive independence axiom of semantic loss. The third Kolmogorov axiom", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 428 + ], + "score": 1.0, + "content": "(for the finite discrete case) is given by the exponential additivity axiom of semantic loss. Hence,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 425, + 507, + 439 + ], + "spans": [ + { + "bbox": [ + 107, + 426, + 151, + 438 + ], + "score": 0.92, + "content": "f ^ { s } ( K , . , { \\mathsf { p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 425, + 344, + 439 + ], + "score": 1.0, + "content": "is a probability distribution for some choice of", + "type": "text" + }, + { + "bbox": [ + 344, + 426, + 354, + 436 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 425, + 507, + 439 + ], + "score": 1.0, + "content": ", which implies the definition up to a", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 437, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 201, + 448 + ], + "score": 1.0, + "content": "multiplicative constant.", + "type": "text" + }, + { + "bbox": [ + 494, + 437, + 506, + 448 + ], + "score": 0.999, + "content": "□", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 381, + 507, + 448 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 465, + 485, + 478 + ], + "lines": [ + { + "bbox": [ + 104, + 464, + 488, + 479 + ], + "spans": [ + { + "bbox": [ + 104, + 464, + 488, + 479 + ], + "score": 1.0, + "content": "B SPECIFICATION OF THE CONVOLUTIONAL NEURAL NETWORK MODEL", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 490, + 505, + 546 + ], + "lines": [ + { + "bbox": [ + 107, + 491, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 107, + 491, + 505, + 501 + ], + "score": 1.0, + "content": "Table 6 shows the slight architectural difference between the CNN used in ladder nets and ours. The", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "major difference lies in the choice of ReLu. Note we add standard padded cropping to preprocess", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "images and an additional fully connected layer at the end of the model, neither is used in ladder nets.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "We only make those slight modification so that the baseline performance reported by Rasmus et al.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 534, + 213, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 534, + 213, + 547 + ], + "score": 1.0, + "content": "(2015) can be reproduced.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 491, + 505, + 547 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 562, + 324, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 561, + 325, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 325, + 577 + ], + "score": 1.0, + "content": "C HYPER-PARAMETER TUNING DETAILS", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 643 + ], + "lines": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 505, + 601 + ], + "score": 1.0, + "content": "Validation sets are used for tuning the weight associated with semantic loss, the only hyper-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "parameter that causes noticeable difference in performance for our method. For our semi-supervised", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 338, + 622 + ], + "score": 1.0, + "content": "classification experiments, we perform a grid search over", + "type": "text" + }, + { + "bbox": [ + 338, + 610, + 460, + 622 + ], + "score": 0.88, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "to find the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 506, + 635 + ], + "score": 1.0, + "content": "optimal value. Empirically, 0.005 always gives the best or nearly the best results and we report its", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 632, + 213, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 213, + 644 + ], + "score": 1.0, + "content": "results on all experiments.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 587, + 506, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "For the FASHION dataset specifically, because MNIST and FASHION share the same image size", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 673 + ], + "score": 1.0, + "content": "and structure, methods developed in MNIST should be able to directly perform on FASHION with-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "out heavy modifications. Because of this, we use the same hyper-parameters when evaluating our", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 695 + ], + "score": 1.0, + "content": "method. However, for the sake of fairness, we subject ladder nets to a small-scale parameter tuning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 693, + 267, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 267, + 705 + ], + "score": 1.0, + "content": "in case its performance is more volatile.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 649, + 506, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "For the grids experiment, the only hyper parameter that needed to be tuned was again the weight", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 278, + 733 + ], + "score": 1.0, + "content": "given to semantic loss, which after trying", + "type": "text" + }, + { + "bbox": [ + 278, + 720, + 426, + 732 + ], + "score": 0.87, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 , 0 . 5 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 427, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "was selected to be", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 173, + 100, + 437, + 318 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 156, + 80, + 453, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 79, + 453, + 93 + ], + "spans": [ + { + "bbox": [ + 157, + 79, + 453, + 93 + ], + "score": 1.0, + "content": "Table 6: Specifications of CNNs in Ladder Net and our proposed method.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 173, + 100, + 437, + 318 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 173, + 100, + 437, + 318 + ], + "spans": [ + { + "bbox": [ + 173, + 100, + 437, + 318 + ], + "score": 0.978, + "html": "
CNNinLadderNetCNN in this paper
Input 32×32 RGB image
Resizing to 36 × 36 with padding Cropping Back
Whitening Contrast Normalization
Gaussian Noise with std.of 0.3
3 ×3 conv. 96 BNLeakyReLU3×3 conv. 96 BN ReLU
3×3 conv. 96 BNLeakyReLU3 ×3 conv. 96 BN ReLU
3 ×3 conv. 96 BNLeakyReLU3×3 conv. 96 BN ReLU
2×2 max-pooling stride 2 BN
3×3 conv.192BNLeakyReLU3×3 conv.192 BN ReLU
3×3 conv.192 BNLeakyReLU3×3 conv. 192 BN ReLU
3×3 conv.192 BN LeakyReLU3×3 conv.192 BN ReLU
2×2 max-pooling stride 2 BN
3×3conv.192BNLeakyReLU3×3conv.192 BNReLU
1×1 conv.192 BN LeakyReLU3×3 conv. 192 BN ReLU
1×1conv.10 BNLeakyReLU1×1 conv. 10 BN ReLu
global meanpool BN
fully connected BN
10-way softmax
", + "type": "table", + "image_path": "358350f5d93ca940af966331f2a65fafdad421d46e88d1ecac1a9dcd0bdc9a55.jpg" + } + ] + } + ], + "index": 8.5, + "virtual_lines": [ + { + "bbox": [ + 173, + 100, + 437, + 113.625 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 173, + 113.625, + 437, + 127.25 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 173, + 127.25, + 437, + 140.875 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 173, + 140.875, + 437, + 154.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 173, + 154.5, + 437, + 168.125 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 173, + 168.125, + 437, + 181.75 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 173, + 181.75, + 437, + 195.375 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 173, + 195.375, + 437, + 209.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 173, + 209.0, + 437, + 222.625 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 173, + 222.625, + 437, + 236.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 173, + 236.25, + 437, + 249.875 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 173, + 249.875, + 437, + 263.5 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 173, + 263.5, + 437, + 277.125 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 173, + 277.125, + 437, + 290.75 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 173, + 290.75, + 437, + 304.375 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 173, + 304.375, + 437, + 318.0 + ], + "spans": [], + "index": 16 + } + ] + } + ], + "index": 4.25 + }, + { + "type": "text", + "bbox": [ + 108, + 339, + 503, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "0.5 based on validation results. For the preference learning experiment, we initially chose the se-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 350, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 210, + 362 + ], + "score": 1.0, + "content": "mantic loss weight from", + "type": "text" + }, + { + "bbox": [ + 211, + 350, + 359, + 362 + ], + "score": 0.9, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 , 0 . 5 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 350, + 505, + 362 + ], + "score": 1.0, + "content": "to be 0.1 based on validation, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 360, + 258, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 258, + 373 + ], + "score": 1.0, + "content": "then further tuned the weight to 0.25.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 107, + 388, + 397, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 398, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 398, + 403 + ], + "score": 1.0, + "content": "D SPECIFICATION OF COMPLEX CONSTRAINT MODELS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 413, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "Grids To compile our grid constraint, we first use Nishino et al. (2017) to generate a constraint", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "for each source destination pair. Then, we conjoin each of these with indicators specifying which", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 436, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 448 + ], + "score": 1.0, + "content": "source and destination pair must be used, and finally we disjoin all of these together to form our", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 151, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 151, + 457 + ], + "score": 1.0, + "content": "constraint.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 476 + ], + "score": 1.0, + "content": "To generate the data, we begin by randomly removing one third of edges. We then filter out con-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 474, + 504, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 504, + 486 + ], + "score": 1.0, + "content": "nected components with fewer than 5 nodes to reduce degenerate cases, and proceed with randomly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 485, + 286, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 286, + 498 + ], + "score": 1.0, + "content": "selecting pairs of point to create data points.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 504, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "The predictive model we employ as our baseline is a 5 layer MLP with 50 hidden sigmoid units", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "score": 1.0, + "content": "per layer. It is trained using Adam Optimizer, with full data batches (Kingma & Ba, 2015). Early", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 524, + 360, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 360, + 537 + ], + "score": 1.0, + "content": "stopping with respect to validation loss is used as a regularizer.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 547, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "Preference Learning We split each user’s ordering into their ordering over sushis 1,2,3,5,7,8,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "which we use as the features, and their ordering over 4,6,9,10 which are the labels we predict. The", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "constraint is compiled directly from logic, as this can be done in a straightforward manner for an", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 580, + 173, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 173, + 594 + ], + "score": 1.0, + "content": "n-item ordering.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 108, + 597, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "The predictive model we use here is a 3 layer MLP with 25 hidden sigmoid units per layer. It is", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "trained using Adam Optimizer with full data batches (Kingma & Ba, 2015). Early stopping with", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 620, + 302, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 302, + 631 + ], + "score": 1.0, + "content": "respect to validation loss is used as a regularizer.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 173, + 100, + 437, + 318 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 156, + 80, + 453, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 79, + 453, + 93 + ], + "spans": [ + { + "bbox": [ + 157, + 79, + 453, + 93 + ], + "score": 1.0, + "content": "Table 6: Specifications of CNNs in Ladder Net and our proposed method.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 173, + 100, + 437, + 318 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 173, + 100, + 437, + 318 + ], + "spans": [ + { + "bbox": [ + 173, + 100, + 437, + 318 + ], + "score": 0.978, + "html": "
CNNinLadderNetCNN in this paper
Input 32×32 RGB image
Resizing to 36 × 36 with padding Cropping Back
Whitening Contrast Normalization
Gaussian Noise with std.of 0.3
3 ×3 conv. 96 BNLeakyReLU3×3 conv. 96 BN ReLU
3×3 conv. 96 BNLeakyReLU3 ×3 conv. 96 BN ReLU
3 ×3 conv. 96 BNLeakyReLU3×3 conv. 96 BN ReLU
2×2 max-pooling stride 2 BN
3×3 conv.192BNLeakyReLU3×3 conv.192 BN ReLU
3×3 conv.192 BNLeakyReLU3×3 conv. 192 BN ReLU
3×3 conv.192 BN LeakyReLU3×3 conv.192 BN ReLU
2×2 max-pooling stride 2 BN
3×3conv.192BNLeakyReLU3×3conv.192 BNReLU
1×1 conv.192 BN LeakyReLU3×3 conv. 192 BN ReLU
1×1conv.10 BNLeakyReLU1×1 conv. 10 BN ReLu
global meanpool BN
fully connected BN
10-way softmax
", + "type": "table", + "image_path": "358350f5d93ca940af966331f2a65fafdad421d46e88d1ecac1a9dcd0bdc9a55.jpg" + } + ] + } + ], + "index": 8.5, + "virtual_lines": [ + { + "bbox": [ + 173, + 100, + 437, + 113.625 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 173, + 113.625, + 437, + 127.25 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 173, + 127.25, + 437, + 140.875 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 173, + 140.875, + 437, + 154.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 173, + 154.5, + 437, + 168.125 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 173, + 168.125, + 437, + 181.75 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 173, + 181.75, + 437, + 195.375 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 173, + 195.375, + 437, + 209.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 173, + 209.0, + 437, + 222.625 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 173, + 222.625, + 437, + 236.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 173, + 236.25, + 437, + 249.875 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 173, + 249.875, + 437, + 263.5 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 173, + 263.5, + 437, + 277.125 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 173, + 277.125, + 437, + 290.75 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 173, + 290.75, + 437, + 304.375 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 173, + 304.375, + 437, + 318.0 + ], + "spans": [], + "index": 16 + } + ] + } + ], + "index": 4.25 + }, + { + "type": "text", + "bbox": [ + 108, + 339, + 503, + 372 + ], + "lines": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "0.5 based on validation results. For the preference learning experiment, we initially chose the se-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 350, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 210, + 362 + ], + "score": 1.0, + "content": "mantic loss weight from", + "type": "text" + }, + { + "bbox": [ + 211, + 350, + 359, + 362 + ], + "score": 0.9, + "content": "\\{ 0 . 0 0 1 , 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 , 0 . 5 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 350, + 505, + 362 + ], + "score": 1.0, + "content": "to be 0.1 based on validation, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 360, + 258, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 258, + 373 + ], + "score": 1.0, + "content": "then further tuned the weight to 0.25.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 338, + 505, + 373 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 388, + 397, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 387, + 398, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 398, + 403 + ], + "score": 1.0, + "content": "D SPECIFICATION OF COMPLEX CONSTRAINT MODELS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 413, + 505, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "Grids To compile our grid constraint, we first use Nishino et al. (2017) to generate a constraint", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "for each source destination pair. Then, we conjoin each of these with indicators specifying which", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 436, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 505, + 448 + ], + "score": 1.0, + "content": "source and destination pair must be used, and finally we disjoin all of these together to form our", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 447, + 151, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 151, + 457 + ], + "score": 1.0, + "content": "constraint.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 412, + 506, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 497 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 476 + ], + "score": 1.0, + "content": "To generate the data, we begin by randomly removing one third of edges. We then filter out con-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 474, + 504, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 504, + 486 + ], + "score": 1.0, + "content": "nected components with fewer than 5 nodes to reduce degenerate cases, and proceed with randomly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 485, + 286, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 286, + 498 + ], + "score": 1.0, + "content": "selecting pairs of point to create data points.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 462, + 505, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 504, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "The predictive model we employ as our baseline is a 5 layer MLP with 50 hidden sigmoid units", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "score": 1.0, + "content": "per layer. It is trained using Adam Optimizer, with full data batches (Kingma & Ba, 2015). Early", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 524, + 360, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 360, + 537 + ], + "score": 1.0, + "content": "stopping with respect to validation loss is used as a regularizer.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 502, + 505, + 537 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 547, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "Preference Learning We split each user’s ordering into their ordering over sushis 1,2,3,5,7,8,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "which we use as the features, and their ordering over 4,6,9,10 which are the labels we predict. The", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "constraint is compiled directly from logic, as this can be done in a straightforward manner for an", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 580, + 173, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 173, + 594 + ], + "score": 1.0, + "content": "n-item ordering.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 546, + 505, + 594 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 597, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 610 + ], + "score": 1.0, + "content": "The predictive model we use here is a 3 layer MLP with 25 hidden sigmoid units per layer. It is", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 622 + ], + "score": 1.0, + "content": "trained using Adam Optimizer with full data batches (Kingma & Ba, 2015). Early stopping with", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 620, + 302, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 302, + 631 + ], + "score": 1.0, + "content": "respect to validation loss is used as a regularizer.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 597, + 505, + 631 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file