diff --git "a/parse/train/S18Su--CW/S18Su--CW_middle.json" "b/parse/train/S18Su--CW/S18Su--CW_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/S18Su--CW/S18Su--CW_middle.json" @@ -0,0 +1,41679 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "THERMOMETER ENCODING: ONE HOT WAY TO RESIST", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 304, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 304, + 118 + ], + "score": 1.0, + "content": "ADVERSARIAL EXAMPLES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 113, + 135, + 405, + 180 + ], + "lines": [ + { + "bbox": [ + 111, + 134, + 367, + 148 + ], + "spans": [ + { + "bbox": [ + 111, + 134, + 367, + 148 + ], + "score": 1.0, + "content": "Jacob Buckman∗ †, Aurko Roy∗, Colin Raffel, Ian Goodfellow", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 169, + 158 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 169, + 158 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 111, + 156, + 195, + 168 + ], + "spans": [ + { + "bbox": [ + 111, + 156, + 195, + 168 + ], + "score": 1.0, + "content": "Mountain View, CA", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 112, + 168, + 406, + 181 + ], + "spans": [ + { + "bbox": [ + 112, + 168, + 406, + 181 + ], + "score": 1.0, + "content": "{buckman, aurkor, craffel, goodfellow}@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 278, + 208, + 333, + 220 + ], + "lines": [ + { + "bbox": [ + 276, + 208, + 335, + 221 + ], + "spans": [ + { + "bbox": [ + 276, + 208, + 335, + 221 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 234, + 468, + 365 + ], + "lines": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "score": 1.0, + "content": "It is well known that it is possible to construct “adversarial examples” for neu-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 244, + 469, + 257 + ], + "spans": [ + { + "bbox": [ + 141, + 244, + 469, + 257 + ], + "score": 1.0, + "content": "ral networks: inputs which are misclassified by the network yet indistinguishable", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 255, + 469, + 268 + ], + "spans": [ + { + "bbox": [ + 141, + 255, + 469, + 268 + ], + "score": 1.0, + "content": "from true data. We propose a simple modification to standard neural network ar-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "score": 1.0, + "content": "chitectures, thermometer encoding, which significantly increases the robustness", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 277, + 469, + 289 + ], + "spans": [ + { + "bbox": [ + 141, + 277, + 469, + 289 + ], + "score": 1.0, + "content": "of the network to adversarial examples. We demonstrate this robustness with ex-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 289, + 469, + 300 + ], + "spans": [ + { + "bbox": [ + 141, + 289, + 469, + 300 + ], + "score": 1.0, + "content": "periments on the MNIST, CIFAR-10, CIFAR-100, and SVHN datasets, and show", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "spans": [ + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "score": 1.0, + "content": "that models with thermometer-encoded inputs consistently have higher accuracy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 310, + 470, + 324 + ], + "spans": [ + { + "bbox": [ + 141, + 310, + 470, + 324 + ], + "score": 1.0, + "content": "on adversarial examples, without decreasing generalization. State-of-the-art accu-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 321, + 469, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 322, + 425, + 333 + ], + "score": 1.0, + "content": "racy under the strongest known white-box attack was increased from", + "type": "text" + }, + { + "bbox": [ + 425, + 321, + 457, + 332 + ], + "score": 0.87, + "content": "9 3 . 2 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 322, + 469, + 333 + ], + "score": 1.0, + "content": "to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 142, + 331, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 142, + 333, + 174, + 343 + ], + "score": 0.87, + "content": "9 4 . 3 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 331, + 238, + 345 + ], + "score": 1.0, + "content": "on MNIST and", + "type": "text" + }, + { + "bbox": [ + 239, + 333, + 271, + 343 + ], + "score": 0.87, + "content": "5 0 . 0 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 331, + 281, + 345 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 282, + 333, + 314, + 343 + ], + "score": 0.88, + "content": "7 9 . 1 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 331, + 469, + 345 + ], + "score": 1.0, + "content": "on CIFAR-10. We explore the proper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 343, + 470, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 470, + 356 + ], + "score": 1.0, + "content": "ties of these networks, providing evidence that thermometer encodings help neural", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 354, + 361, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 361, + 366 + ], + "score": 1.0, + "content": "networks to find more-non-linear decision boundaries.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 108, + 387, + 319, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 321, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 321, + 401 + ], + "score": 1.0, + "content": "1 INTRODUCTION AND RELATED WORK", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 412, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 506, + 425 + ], + "score": 1.0, + "content": "Adversarial examples are inputs to machine learning models that are intentionally designed to cause", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 423, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 505, + 435 + ], + "score": 1.0, + "content": "the model to produce an incorrect output. The term was introduced by Szegedy et al. (2014) in the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "score": 1.0, + "content": "context of neural networks for computer vision. In the context of spam and malware detection, such", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "inputs have been studied earlier under the name evasion attacks (Biggio et al., 2013). Adversarial", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "score": 1.0, + "content": "examples are interesting from a scientific perspective, because they demonstrate that even machine", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "learning models that have superhuman performance on I.I.D. test sets fail catastrophically on in-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "score": 1.0, + "content": "puts that are modified even slightly by an adversary. Adversarial examples also raise concerns in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "the emerging field of machine learning security because malicious attackers could use adversarial", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 500, + 353, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 353, + 512 + ], + "score": 1.0, + "content": "examples to cause undesired behavior (Papernot et al., 2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "Unfortunately, there is not yet any known strong defense against adversarial examples. Adversarial", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "examples that fool one model often fool another model, even if the two models are trained on dif-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "ferent training examples (corresponding to the same task) or have different architectures (Szegedy", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "score": 1.0, + "content": "et al., 2014), so an attacker can fool a model without access to it. Attackers can improve their success", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "rate by sending inputs to a model, observing its output, and fitting their own own copy of the model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 571, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 584 + ], + "score": 1.0, + "content": "to the observed input-output pairs (Papernot et al., 2016). Attackers can also improve their success", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 582, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 104, + 582, + 505, + 594 + ], + "score": 1.0, + "content": "rate by searching for adversarial examples that fool multiple different models—such adversarial ex-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "amples are then much more likely to fool the unknown target model (Liu et al., 2016). Szegedy et al.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "(2014) proposed to defend the model using adversarial training (training on adversarial examples as", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "well as regular examples) but it was not feasible to generate enough adversarial examples in the in-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 626, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 104, + 626, + 506, + 639 + ], + "score": 1.0, + "content": "ner loop of the training process for the method to be effective at the time. Szegedy et al. (2014) used", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "a large number of iterations of L-BFGS to produce their adversarial examples. Goodfellow et al.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "score": 1.0, + "content": "(2014) developed the fast gradient sign method (FGSM) of generating adversarial examples and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 658, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 506, + 672 + ], + "score": 1.0, + "content": "demonstrated that adversarial training is effective for reducing the error rate on adversarial exam-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "score": 1.0, + "content": "ples. A major difficulty of adversarial training is that it tends to overfit to the method of adversarial", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 681, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 693 + ], + "score": 1.0, + "content": "example generation used at training time. For example, models trained to resist FGSM adversarial", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 691, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 505, + 704 + ], + "score": 1.0, + "content": "examples usually fail to resist L-BFGS adversarial examples. Kurakin et al. (2016) introduced the", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 37 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 712, + 442, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 195, + 722 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 195, + 722 + ], + "score": 1.0, + "content": "∗Equal contribution.", + "type": "text" + } + ] + }, + { + "bbox": [ + 117, + 719, + 442, + 734 + ], + "spans": [ + { + "bbox": [ + 117, + 719, + 442, + 734 + ], + "score": 1.0, + "content": "†Work done as a member of the Google AI Residency program (g.co/airesidency)", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 502, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "THERMOMETER ENCODING: ONE HOT WAY TO RESIST", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 304, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 304, + 118 + ], + "score": 1.0, + "content": "ADVERSARIAL EXAMPLES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "list", + "bbox": [ + 113, + 135, + 405, + 180 + ], + "lines": [ + { + "bbox": [ + 111, + 134, + 367, + 148 + ], + "spans": [ + { + "bbox": [ + 111, + 134, + 367, + 148 + ], + "score": 1.0, + "content": "Jacob Buckman∗ †, Aurko Roy∗, Colin Raffel, Ian Goodfellow", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 146, + 169, + 158 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 169, + 158 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 156, + 195, + 168 + ], + "spans": [ + { + "bbox": [ + 111, + 156, + 195, + 168 + ], + "score": 1.0, + "content": "Mountain View, CA", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 168, + 406, + 181 + ], + "spans": [ + { + "bbox": [ + 112, + 168, + 406, + 181 + ], + "score": 1.0, + "content": "{buckman, aurkor, craffel, goodfellow}@google.com", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + } + ], + "index": 3.5, + "bbox_fs": [ + 111, + 134, + 406, + 181 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 208, + 333, + 220 + ], + "lines": [ + { + "bbox": [ + 276, + 208, + 335, + 221 + ], + "spans": [ + { + "bbox": [ + 276, + 208, + 335, + 221 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 143, + 234, + 468, + 365 + ], + "lines": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 469, + 246 + ], + "score": 1.0, + "content": "It is well known that it is possible to construct “adversarial examples” for neu-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 244, + 469, + 257 + ], + "spans": [ + { + "bbox": [ + 141, + 244, + 469, + 257 + ], + "score": 1.0, + "content": "ral networks: inputs which are misclassified by the network yet indistinguishable", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 255, + 469, + 268 + ], + "spans": [ + { + "bbox": [ + 141, + 255, + 469, + 268 + ], + "score": 1.0, + "content": "from true data. We propose a simple modification to standard neural network ar-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 142, + 267, + 469, + 279 + ], + "score": 1.0, + "content": "chitectures, thermometer encoding, which significantly increases the robustness", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 277, + 469, + 289 + ], + "spans": [ + { + "bbox": [ + 141, + 277, + 469, + 289 + ], + "score": 1.0, + "content": "of the network to adversarial examples. We demonstrate this robustness with ex-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 289, + 469, + 300 + ], + "spans": [ + { + "bbox": [ + 141, + 289, + 469, + 300 + ], + "score": 1.0, + "content": "periments on the MNIST, CIFAR-10, CIFAR-100, and SVHN datasets, and show", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "spans": [ + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "score": 1.0, + "content": "that models with thermometer-encoded inputs consistently have higher accuracy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 310, + 470, + 324 + ], + "spans": [ + { + "bbox": [ + 141, + 310, + 470, + 324 + ], + "score": 1.0, + "content": "on adversarial examples, without decreasing generalization. State-of-the-art accu-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 321, + 469, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 322, + 425, + 333 + ], + "score": 1.0, + "content": "racy under the strongest known white-box attack was increased from", + "type": "text" + }, + { + "bbox": [ + 425, + 321, + 457, + 332 + ], + "score": 0.87, + "content": "9 3 . 2 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 322, + 469, + 333 + ], + "score": 1.0, + "content": "to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 142, + 331, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 142, + 333, + 174, + 343 + ], + "score": 0.87, + "content": "9 4 . 3 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 331, + 238, + 345 + ], + "score": 1.0, + "content": "on MNIST and", + "type": "text" + }, + { + "bbox": [ + 239, + 333, + 271, + 343 + ], + "score": 0.87, + "content": "5 0 . 0 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 331, + 281, + 345 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 282, + 333, + 314, + 343 + ], + "score": 0.88, + "content": "7 9 . 1 6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 331, + 469, + 345 + ], + "score": 1.0, + "content": "on CIFAR-10. We explore the proper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 343, + 470, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 470, + 356 + ], + "score": 1.0, + "content": "ties of these networks, providing evidence that thermometer encodings help neural", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 354, + 361, + 366 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 361, + 366 + ], + "score": 1.0, + "content": "networks to find more-non-linear decision boundaries.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12.5, + "bbox_fs": [ + 141, + 233, + 470, + 366 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 387, + 319, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 321, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 321, + 401 + ], + "score": 1.0, + "content": "1 INTRODUCTION AND RELATED WORK", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 412, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 506, + 425 + ], + "score": 1.0, + "content": "Adversarial examples are inputs to machine learning models that are intentionally designed to cause", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 423, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 505, + 435 + ], + "score": 1.0, + "content": "the model to produce an incorrect output. The term was introduced by Szegedy et al. (2014) in the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 505, + 446 + ], + "score": 1.0, + "content": "context of neural networks for computer vision. In the context of spam and malware detection, such", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "inputs have been studied earlier under the name evasion attacks (Biggio et al., 2013). Adversarial", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 469 + ], + "score": 1.0, + "content": "examples are interesting from a scientific perspective, because they demonstrate that even machine", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "learning models that have superhuman performance on I.I.D. test sets fail catastrophically on in-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 491 + ], + "score": 1.0, + "content": "puts that are modified even slightly by an adversary. Adversarial examples also raise concerns in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "the emerging field of machine learning security because malicious attackers could use adversarial", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 500, + 353, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 353, + 512 + ], + "score": 1.0, + "content": "examples to cause undesired behavior (Papernot et al., 2016).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 411, + 506, + 512 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "Unfortunately, there is not yet any known strong defense against adversarial examples. Adversarial", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "examples that fool one model often fool another model, even if the two models are trained on dif-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "ferent training examples (corresponding to the same task) or have different architectures (Szegedy", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 562 + ], + "score": 1.0, + "content": "et al., 2014), so an attacker can fool a model without access to it. Attackers can improve their success", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "rate by sending inputs to a model, observing its output, and fitting their own own copy of the model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 571, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 505, + 584 + ], + "score": 1.0, + "content": "to the observed input-output pairs (Papernot et al., 2016). Attackers can also improve their success", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 582, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 104, + 582, + 505, + 594 + ], + "score": 1.0, + "content": "rate by searching for adversarial examples that fool multiple different models—such adversarial ex-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "amples are then much more likely to fool the unknown target model (Liu et al., 2016). Szegedy et al.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "(2014) proposed to defend the model using adversarial training (training on adversarial examples as", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "well as regular examples) but it was not feasible to generate enough adversarial examples in the in-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 626, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 104, + 626, + 506, + 639 + ], + "score": 1.0, + "content": "ner loop of the training process for the method to be effective at the time. Szegedy et al. (2014) used", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "a large number of iterations of L-BFGS to produce their adversarial examples. Goodfellow et al.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 660 + ], + "score": 1.0, + "content": "(2014) developed the fast gradient sign method (FGSM) of generating adversarial examples and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 658, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 506, + 672 + ], + "score": 1.0, + "content": "demonstrated that adversarial training is effective for reducing the error rate on adversarial exam-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "score": 1.0, + "content": "ples. A major difficulty of adversarial training is that it tends to overfit to the method of adversarial", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 681, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 693 + ], + "score": 1.0, + "content": "example generation used at training time. For example, models trained to resist FGSM adversarial", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 691, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 505, + 704 + ], + "score": 1.0, + "content": "examples usually fail to resist L-BFGS adversarial examples. Kurakin et al. (2016) introduced the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "basic iterative method (BIM) which lies between FGSM and L-BFGS on a curve trading speed for", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "effectiveness (the BIM consists of running FGSM for a medium number of iterations). Adversarial", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "training using BIM still overfits to the BIM, unfortunately, and different iterative methods can still", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 114, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 104, + 114, + 505, + 129 + ], + "score": 1.0, + "content": "successfully attack the model. Recently, Madry et al. (2017) showed that adversarial training using", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "adversarial examples created by adding random noise before running BIM results in a model that is", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "highly robust against all known attacks on the MNIST dataset. However, it is less effective on more", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 160 + ], + "score": 1.0, + "content": "complex datasets, such as CIFAR. A strategy for training networks which are robust to adversarial", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 160, + 504, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 504, + 170 + ], + "score": 1.0, + "content": "attacks across all contexts is still unknown. In this work, we demonstrate that thermometer code dis-", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 170, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 170, + 506, + 183 + ], + "score": 1.0, + "content": "cretization and one-hot code discretization of real-valued inputs to a model significantly improves", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 181, + 415, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 415, + 193 + ], + "score": 1.0, + "content": "its robustness to adversarial attack, advancing the state of the art in this field.", + "type": "text", + "cross_page": true + } + ], + "index": 9 + } + ], + "index": 37, + "bbox_fs": [ + 104, + 516, + 506, + 704 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 192 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 94 + ], + "score": 1.0, + "content": "basic iterative method (BIM) which lies between FGSM and L-BFGS on a curve trading speed for", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "effectiveness (the BIM consists of running FGSM for a medium number of iterations). Adversarial", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "training using BIM still overfits to the BIM, unfortunately, and different iterative methods can still", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 114, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 104, + 114, + 505, + 129 + ], + "score": 1.0, + "content": "successfully attack the model. Recently, Madry et al. (2017) showed that adversarial training using", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "adversarial examples created by adding random noise before running BIM results in a model that is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "highly robust against all known attacks on the MNIST dataset. However, it is less effective on more", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 148, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 505, + 160 + ], + "score": 1.0, + "content": "complex datasets, such as CIFAR. A strategy for training networks which are robust to adversarial", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 160, + 504, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 504, + 170 + ], + "score": 1.0, + "content": "attacks across all contexts is still unknown. In this work, we demonstrate that thermometer code dis-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 170, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 170, + 506, + 183 + ], + "score": 1.0, + "content": "cretization and one-hot code discretization of real-valued inputs to a model significantly improves", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 181, + 415, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 415, + 193 + ], + "score": 1.0, + "content": "its robustness to adversarial attack, advancing the state of the art in this field.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 108, + 208, + 248, + 221 + ], + "lines": [ + { + "bbox": [ + 105, + 207, + 250, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 250, + 223 + ], + "score": 1.0, + "content": "2 INPUT DISCRETIZATION", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "score": 1.0, + "content": "We propose to break the linear extrapolation behavior of machine learning models by preprocessing", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 257 + ], + "score": 1.0, + "content": "the input with an extremely nonlinear function. This function must still permit the machine learning", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "model to function successfully on naturally occurring inputs. The recent success of the PixelRNN", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 266, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 505, + 277 + ], + "score": 1.0, + "content": "model (Oord et al., 2016) has demonstrated that one-hot discrete codes for 256 possible values", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 277, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 504, + 288 + ], + "score": 1.0, + "content": "of color pixels are effective representations for input data. Other extremely nonlinear functions", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "may also defend against adversarial examples, but we focused attention on vector-valued discrete", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 310 + ], + "score": 1.0, + "content": "encoding as our nonlinear function because of the evidence from PixelRNN that it would support", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 308, + 224, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 224, + 322 + ], + "score": 1.0, + "content": "successful machine learning.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 326, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "score": 1.0, + "content": "Images are often encoded as a 3D tensor of integers in the range [0, 255]. The tensor’s three di-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 338, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 349 + ], + "score": 1.0, + "content": "mensions correspond to the image’s height, width, and color channels (e.g. three for RGB, one for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "greyscale). Each value represents an intensity value for a given color at a given horizontal/vertical", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 359, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 372 + ], + "score": 1.0, + "content": "position. For classification tasks, these values are typically normalized to floating-point approxima-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "tions in the range (0, 1). Input discretization refers to the process of separating these continuous-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "valued pixel inputs into a set of non-overlapping buckets, which are each mapped to a fixed binary", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 394, + 135, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 135, + 404 + ], + "score": 1.0, + "content": "vector.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 408, + 505, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "Past work, for example depth-color-squeezing (Xu et al., 2017), has explored what we will refer to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "as quantization of inputs as a potential defense against adversarial examples. In that approach, each", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 430, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 444 + ], + "score": 1.0, + "content": "pixel value is mapped to the low-bit version of its original value, which is a fixed scalar. The key", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "score": 1.0, + "content": "novel aspect of our approach is that rather than replacing a real number with a number of low bit", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 453, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 465 + ], + "score": 1.0, + "content": "depth, we replace each real number with a binary vector. Different values of the real number activate", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 463, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 477 + ], + "score": 1.0, + "content": "different bits of the input vector. Multiplying the input vector by the network’s weights thus performs", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 475, + 504, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 504, + 487 + ], + "score": 1.0, + "content": "an operation similar to an embedding lookup in a language model, so different input values actually", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 486, + 504, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 504, + 498 + ], + "score": 1.0, + "content": "use different parameters of the network. To avoid confusion, we will consistently refer to scalar-to-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 497, + 504, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 504, + 509 + ], + "score": 1.0, + "content": "scalar precision reduction as quantization and scalar-to-vector encoding schemes as discretization", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "throughout this work. A comparison of these techniques can be seen in Table 1. Note that, unlike", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "depth-color-squeezing, discretization makes a meaningful change to the model, even when it is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 530, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 542 + ], + "score": 1.0, + "content": "configured to use enough discretization levels to avoid losing any information from a traditionally", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 541, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 553 + ], + "score": 1.0, + "content": "formatted computer vision training set; discretizing each pixel to 256 levels will preserve all of the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "score": 1.0, + "content": "information contained in the original image. Discretization defends against adversarial examples by", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 562, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 506, + 575 + ], + "score": 1.0, + "content": "changing which parameters of the model are used, and may also discard information if the number", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 573, + 496, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 496, + 586 + ], + "score": 1.0, + "content": "of discretization levels is low; quantization can only defend the model by discarding information.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 33.5 + }, + { + "type": "table", + "bbox": [ + 141, + 593, + 468, + 640 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 141, + 593, + 468, + 640 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 141, + 593, + 468, + 640 + ], + "spans": [ + { + "bbox": [ + 141, + 593, + 468, + 640 + ], + "score": 0.966, + "html": "
Real-valuedQuantizedDiscretized (one-hot)Discretized (thermometer)
0.130.15[0100000000][0111111111]
0.660.65[0000001000][0000001111]
0.920.95[0000000001][0000000001]
", + "type": "table", + "image_path": "2b2debaaa5e0250083ec71b0d962a430a1c5cdf6fa43b6551dc713a1b11f0c5b.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 141, + 593, + 468, + 608.6666666666666 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 141, + 608.6666666666666, + 468, + 624.3333333333333 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 141, + 624.3333333333333, + 468, + 639.9999999999999 + ], + "spans": [], + "index": 44 + } + ] + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 105, + 648, + 505, + 670 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "score": 1.0, + "content": "Table 1: Examples mapping from continuous-valued inputs to quantized inputs, one-hot codes, and", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 659, + 309, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 309, + 671 + ], + "score": 1.0, + "content": "thermometer codes, with ten evenly-spaced levels.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + }, + { + "type": "title", + "bbox": [ + 107, + 689, + 268, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 689, + 270, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 270, + 701 + ], + "score": 1.0, + "content": "2.1 DISCRETIZATION AS A DEFENSE", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 47 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In Goodfellow et al. (2014), the authors provide evidence that several network architectures, in-", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "cluding LSTMs (Hochreiter & Schmidhuber, 1997), sigmoid networks (Han & Moraga, 1995), and", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 505, + 192 + ], + "lines": [], + "index": 4.5, + "bbox_fs": [ + 104, + 83, + 506, + 193 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 208, + 248, + 221 + ], + "lines": [ + { + "bbox": [ + 105, + 207, + 250, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 250, + 223 + ], + "score": 1.0, + "content": "2 INPUT DISCRETIZATION", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 232, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 232, + 505, + 245 + ], + "score": 1.0, + "content": "We propose to break the linear extrapolation behavior of machine learning models by preprocessing", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 243, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 505, + 257 + ], + "score": 1.0, + "content": "the input with an extremely nonlinear function. This function must still permit the machine learning", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "model to function successfully on naturally occurring inputs. The recent success of the PixelRNN", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 266, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 505, + 277 + ], + "score": 1.0, + "content": "model (Oord et al., 2016) has demonstrated that one-hot discrete codes for 256 possible values", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 277, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 504, + 288 + ], + "score": 1.0, + "content": "of color pixels are effective representations for input data. Other extremely nonlinear functions", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 299 + ], + "score": 1.0, + "content": "may also defend against adversarial examples, but we focused attention on vector-valued discrete", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 310 + ], + "score": 1.0, + "content": "encoding as our nonlinear function because of the evidence from PixelRNN that it would support", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 308, + 224, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 224, + 322 + ], + "score": 1.0, + "content": "successful machine learning.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 232, + 505, + 322 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 326, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 504, + 339 + ], + "score": 1.0, + "content": "Images are often encoded as a 3D tensor of integers in the range [0, 255]. The tensor’s three di-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 338, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 349 + ], + "score": 1.0, + "content": "mensions correspond to the image’s height, width, and color channels (e.g. three for RGB, one for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 361 + ], + "score": 1.0, + "content": "greyscale). Each value represents an intensity value for a given color at a given horizontal/vertical", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 359, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 372 + ], + "score": 1.0, + "content": "position. For classification tasks, these values are typically normalized to floating-point approxima-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "tions in the range (0, 1). Input discretization refers to the process of separating these continuous-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 394 + ], + "score": 1.0, + "content": "valued pixel inputs into a set of non-overlapping buckets, which are each mapped to a fixed binary", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 394, + 135, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 135, + 404 + ], + "score": 1.0, + "content": "vector.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 326, + 505, + 404 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 408, + 505, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "Past work, for example depth-color-squeezing (Xu et al., 2017), has explored what we will refer to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "as quantization of inputs as a potential defense against adversarial examples. In that approach, each", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 430, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 444 + ], + "score": 1.0, + "content": "pixel value is mapped to the low-bit version of its original value, which is a fixed scalar. The key", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 454 + ], + "score": 1.0, + "content": "novel aspect of our approach is that rather than replacing a real number with a number of low bit", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 453, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 465 + ], + "score": 1.0, + "content": "depth, we replace each real number with a binary vector. Different values of the real number activate", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 463, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 477 + ], + "score": 1.0, + "content": "different bits of the input vector. Multiplying the input vector by the network’s weights thus performs", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 475, + 504, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 504, + 487 + ], + "score": 1.0, + "content": "an operation similar to an embedding lookup in a language model, so different input values actually", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 486, + 504, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 504, + 498 + ], + "score": 1.0, + "content": "use different parameters of the network. To avoid confusion, we will consistently refer to scalar-to-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 497, + 504, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 504, + 509 + ], + "score": 1.0, + "content": "scalar precision reduction as quantization and scalar-to-vector encoding schemes as discretization", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "throughout this work. A comparison of these techniques can be seen in Table 1. Note that, unlike", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "depth-color-squeezing, discretization makes a meaningful change to the model, even when it is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 530, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 542 + ], + "score": 1.0, + "content": "configured to use enough discretization levels to avoid losing any information from a traditionally", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 541, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 553 + ], + "score": 1.0, + "content": "formatted computer vision training set; discretizing each pixel to 256 levels will preserve all of the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 564 + ], + "score": 1.0, + "content": "information contained in the original image. Discretization defends against adversarial examples by", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 562, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 506, + 575 + ], + "score": 1.0, + "content": "changing which parameters of the model are used, and may also discard information if the number", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 573, + 496, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 496, + 586 + ], + "score": 1.0, + "content": "of discretization levels is low; quantization can only defend the model by discarding information.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 409, + 506, + 586 + ] + }, + { + "type": "table", + "bbox": [ + 141, + 593, + 468, + 640 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 141, + 593, + 468, + 640 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 141, + 593, + 468, + 640 + ], + "spans": [ + { + "bbox": [ + 141, + 593, + 468, + 640 + ], + "score": 0.966, + "html": "
Real-valuedQuantizedDiscretized (one-hot)Discretized (thermometer)
0.130.15[0100000000][0111111111]
0.660.65[0000001000][0000001111]
0.920.95[0000000001][0000000001]
", + "type": "table", + "image_path": "2b2debaaa5e0250083ec71b0d962a430a1c5cdf6fa43b6551dc713a1b11f0c5b.jpg" + } + ] + } + ], + "index": 43, + "virtual_lines": [ + { + "bbox": [ + 141, + 593, + 468, + 608.6666666666666 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 141, + 608.6666666666666, + 468, + 624.3333333333333 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 141, + 624.3333333333333, + 468, + 639.9999999999999 + ], + "spans": [], + "index": 44 + } + ] + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 105, + 648, + 505, + 670 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 661 + ], + "score": 1.0, + "content": "Table 1: Examples mapping from continuous-valued inputs to quantized inputs, one-hot codes, and", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 659, + 309, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 309, + 671 + ], + "score": 1.0, + "content": "thermometer codes, with ten evenly-spaced levels.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 647, + 506, + 671 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 689, + 268, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 689, + 270, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 270, + 701 + ], + "score": 1.0, + "content": "2.1 DISCRETIZATION AS A DEFENSE", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 47 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In Goodfellow et al. (2014), the authors provide evidence that several network architectures, in-", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "cluding LSTMs (Hochreiter & Schmidhuber, 1997), sigmoid networks (Han & Moraga, 1995), and", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 82, + 504, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 504, + 94 + ], + "score": 1.0, + "content": "maxout networks (Goodfellow et al., 2013), are vulnerable to adversarial examples due to the empir-", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "ical fact that, when trained, the loss function of these networks tends to be highly linear with respect", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 159, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 159, + 118 + ], + "score": 1.0, + "content": "to its inputs.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 48.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 504, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 504, + 94 + ], + "score": 1.0, + "content": "maxout networks (Goodfellow et al., 2013), are vulnerable to adversarial examples due to the empir-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "ical fact that, when trained, the loss function of these networks tends to be highly linear with respect", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 159, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 159, + 118 + ], + "score": 1.0, + "content": "to its inputs.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 165 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "score": 1.0, + "content": "We briefly recall the reasoning of Goodfellow et al. (2014). Assume that we have a logistic regressor", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 185, + 144 + ], + "score": 1.0, + "content": "with weight matrix", + "type": "text" + }, + { + "bbox": [ + 185, + 134, + 193, + 142 + ], + "score": 0.68, + "content": "w", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 131, + 275, + 144 + ], + "score": 1.0, + "content": ". Consider an image", + "type": "text" + }, + { + "bbox": [ + 275, + 133, + 306, + 142 + ], + "score": 0.91, + "content": "x \\in \\mathbb { R } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 131, + 402, + 144 + ], + "score": 1.0, + "content": "which is perturbed into", + "type": "text" + }, + { + "bbox": [ + 402, + 132, + 444, + 144 + ], + "score": 0.92, + "content": "\\widetilde { x } = x + \\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "by some noise", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 144, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 107, + 146, + 113, + 155 + ], + "score": 0.77, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 144, + 154, + 156 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 154, + 144, + 198, + 156 + ], + "score": 0.93, + "content": "\\| \\eta \\| _ { \\infty } \\le \\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 144, + 237, + 156 + ], + "score": 1.0, + "content": "for some", + "type": "text" + }, + { + "bbox": [ + 237, + 146, + 243, + 153 + ], + "score": 0.68, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 144, + 506, + 156 + ], + "score": 1.0, + "content": ". The probability that the model assigns to the true class is equal", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 120, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 120, + 166 + ], + "score": 1.0, + "content": "to:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "interline_equation", + "bbox": [ + 195, + 173, + 415, + 188 + ], + "lines": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "spans": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "score": 0.89, + "content": "\\mathbb { L } ( \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } ( \\boldsymbol { x } + \\boldsymbol { \\eta } ) ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\boldsymbol { x } + \\boldsymbol { w } ^ { \\top } \\boldsymbol { \\eta } )", + "type": "interline_equation", + "image_path": "19342409ab6abf187cc42b5a103711c42ce0001751866826710f083b65402c8c.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 197, + 505, + 249 + ], + "lines": [ + { + "bbox": [ + 104, + 198, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 104, + 199, + 182, + 215 + ], + "score": 1.0, + "content": "If the perturbation", + "type": "text" + }, + { + "bbox": [ + 182, + 204, + 189, + 213 + ], + "score": 0.81, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 199, + 352, + 215 + ], + "score": 1.0, + "content": "is adversarial, such as in the case where", + "type": "text" + }, + { + "bbox": [ + 352, + 198, + 443, + 218 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\eta _ { i } : = \\varepsilon \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } ( x ) } { \\partial x _ { i } } \\right) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 199, + 505, + 214 + ], + "score": 1.0, + "content": ", then the input", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 214, + 504, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 229, + 228 + ], + "score": 1.0, + "content": "to the sigmoid is increased by", + "type": "text" + }, + { + "bbox": [ + 229, + 217, + 249, + 226 + ], + "score": 0.85, + "content": "\\varepsilon \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 214, + 263, + 228 + ], + "score": 1.0, + "content": ". If", + "type": "text" + }, + { + "bbox": [ + 263, + 218, + 271, + 226 + ], + "score": 0.79, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 214, + 504, + 228 + ], + "score": 1.0, + "content": "is large, as is typically the case in images and other high-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 481, + 239 + ], + "score": 1.0, + "content": "dimensional spaces of interest, this linearity implies that even imperceptibly small values of", + "type": "text" + }, + { + "bbox": [ + 481, + 228, + 487, + 236 + ], + "score": 0.72, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "can", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 238, + 495, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 495, + 249 + ], + "score": 1.0, + "content": "have a large effect on the model’s prediction, making the model vulnerable to adversarial attacks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 254, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "Though neural networks in principle have the capacity to represent highly nonlinear functions, net-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "works trained via stochastic gradient descent on real-world datasets tend to converge to mostly-linear", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "solutions. This is illustrated in the empirical studies conducted by Goodfellow et al. (2014). One", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "hypothesis proposed to explain this phenomenon is that the nonlinearities typically used in networks", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "score": 1.0, + "content": "are either piecewise linear, like ReLUs, or approximately linear in the parts of their domain in which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 309, + 294, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 294, + 322 + ], + "score": 1.0, + "content": "training takes place, like the sigmoid function.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 505, + 415 + ], + "lines": [ + { + "bbox": [ + 107, + 327, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 107, + 327, + 505, + 338 + ], + "score": 1.0, + "content": "One potential solution to this problem is to use more non-linear activation functions, such as", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 337, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 350 + ], + "score": 1.0, + "content": "quadratic or RBF units. Indeed, it was shown by Goodfellow et al. (2014) that such units were", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "more resistant to adversarial perturbations of their inputs. However, these units are difficult to train,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 358, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 372 + ], + "score": 1.0, + "content": "and the resulting models do not generalize very well (Goodfellow et al., 2014), sacrificing accuracy", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "on clean examples. As an alternative to introducing highly non-linear activation functions in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 381, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 506, + 393 + ], + "score": 1.0, + "content": "network, we propose applying a non-differentiable and non-linear transformation (discretization) to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 393, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 505, + 405 + ], + "score": 1.0, + "content": "the input, before passing it into the model. A comparison of the input to the model under various", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 403, + 499, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 499, + 416 + ], + "score": 1.0, + "content": "regimes can be seen in Figure 1, highlighting the strong non-linearity of discretization techniques.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5 + }, + { + "type": "image", + "bbox": [ + 117, + 438, + 492, + 583 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 117, + 438, + 492, + 583 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 438, + 492, + 583 + ], + "spans": [ + { + "bbox": [ + 117, + 438, + 492, + 583 + ], + "score": 0.969, + "type": "image", + "image_path": "1babc487bea1da3867ddd67e758440fd4bfd2a7dd066a336fbbff60b9365e8fd.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 117, + 438, + 492, + 486.3333333333333 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 117, + 486.3333333333333, + 492, + 534.6666666666666 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 117, + 534.6666666666666, + 492, + 583.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 506, + 713 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "Figure 1: Comparison of regular inputs, quantized inputs, and discretized inputs (16 levels, projected", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 604, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 328, + 616 + ], + "score": 1.0, + "content": "to one dimension) on MNIST, adversarially trained with", + "type": "text" + }, + { + "bbox": [ + 328, + 604, + 360, + 614 + ], + "score": 0.9, + "content": "\\varepsilon = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 604, + 381, + 616 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 382, + 605, + 389, + 613 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 604, + 506, + 616 + ], + "score": 1.0, + "content": "-axis represents the true pixel", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 615, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 215, + 626 + ], + "score": 1.0, + "content": "value of the image, and the", + "type": "text" + }, + { + "bbox": [ + 215, + 616, + 222, + 626 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 615, + 505, + 626 + ], + "score": 1.0, + "content": "-axis represents the value that is passed as input to the network after the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "score": 1.0, + "content": "input transformation has been applied. For real-valued inputs, the inputs to the network are affected", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 635, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 650 + ], + "score": 1.0, + "content": "linearly by perturbations to the input. Quantized inputs are also affected approximately linearly by", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 187, + 660 + ], + "score": 1.0, + "content": "perturbations where", + "type": "text" + }, + { + "bbox": [ + 187, + 649, + 194, + 657 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 648, + 506, + 660 + ], + "score": 1.0, + "content": "is greater than the bucket width. Discretizing the input, and then using learned", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "weights to project the discretized value back to a single scalar, we see that the model has learned", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 669, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 682 + ], + "score": 1.0, + "content": "a highly non-linear function to represent the input in a fashion that is effective for resisting the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "adversarial perturbations it has seen. When starting at the most common pixel-values for MNIST,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 690, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 690, + 298, + 705 + ], + "score": 1.0, + "content": "0 and 1, any perturbation of the pixels (where", + "type": "text" + }, + { + "bbox": [ + 298, + 692, + 335, + 703 + ], + "score": 0.87, + "content": "\\varepsilon \\le 0 . 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 690, + 506, + 705 + ], + "score": 1.0, + "content": ") has barely any effect on the input to the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 703, + 144, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 703, + 144, + 713 + ], + "score": 1.0, + "content": "network.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 34 + } + ], + "index": 30.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 118 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 165 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "score": 1.0, + "content": "We briefly recall the reasoning of Goodfellow et al. (2014). Assume that we have a logistic regressor", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 185, + 144 + ], + "score": 1.0, + "content": "with weight matrix", + "type": "text" + }, + { + "bbox": [ + 185, + 134, + 193, + 142 + ], + "score": 0.68, + "content": "w", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 131, + 275, + 144 + ], + "score": 1.0, + "content": ". Consider an image", + "type": "text" + }, + { + "bbox": [ + 275, + 133, + 306, + 142 + ], + "score": 0.91, + "content": "x \\in \\mathbb { R } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 131, + 402, + 144 + ], + "score": 1.0, + "content": "which is perturbed into", + "type": "text" + }, + { + "bbox": [ + 402, + 132, + 444, + 144 + ], + "score": 0.92, + "content": "\\widetilde { x } = x + \\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "by some noise", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 144, + 506, + 156 + ], + "spans": [ + { + "bbox": [ + 107, + 146, + 113, + 155 + ], + "score": 0.77, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 144, + 154, + 156 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 154, + 144, + 198, + 156 + ], + "score": 0.93, + "content": "\\| \\eta \\| _ { \\infty } \\le \\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 144, + 237, + 156 + ], + "score": 1.0, + "content": "for some", + "type": "text" + }, + { + "bbox": [ + 237, + 146, + 243, + 153 + ], + "score": 0.68, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 144, + 506, + 156 + ], + "score": 1.0, + "content": ". The probability that the model assigns to the true class is equal", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 120, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 120, + 166 + ], + "score": 1.0, + "content": "to:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 120, + 506, + 166 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 195, + 173, + 415, + 188 + ], + "lines": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "spans": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "score": 0.89, + "content": "\\mathbb { L } ( \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } ( \\boldsymbol { x } + \\boldsymbol { \\eta } ) ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\boldsymbol { x } + \\boldsymbol { w } ^ { \\top } \\boldsymbol { \\eta } )", + "type": "interline_equation", + "image_path": "19342409ab6abf187cc42b5a103711c42ce0001751866826710f083b65402c8c.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 195, + 173, + 415, + 188 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 197, + 505, + 249 + ], + "lines": [ + { + "bbox": [ + 104, + 198, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 104, + 199, + 182, + 215 + ], + "score": 1.0, + "content": "If the perturbation", + "type": "text" + }, + { + "bbox": [ + 182, + 204, + 189, + 213 + ], + "score": 0.81, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 199, + 352, + 215 + ], + "score": 1.0, + "content": "is adversarial, such as in the case where", + "type": "text" + }, + { + "bbox": [ + 352, + 198, + 443, + 218 + ], + "score": 0.92, + "content": "\\begin{array} { r } { \\eta _ { i } : = \\varepsilon \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } ( x ) } { \\partial x _ { i } } \\right) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 199, + 505, + 214 + ], + "score": 1.0, + "content": ", then the input", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 214, + 504, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 229, + 228 + ], + "score": 1.0, + "content": "to the sigmoid is increased by", + "type": "text" + }, + { + "bbox": [ + 229, + 217, + 249, + 226 + ], + "score": 0.85, + "content": "\\varepsilon \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 214, + 263, + 228 + ], + "score": 1.0, + "content": ". If", + "type": "text" + }, + { + "bbox": [ + 263, + 218, + 271, + 226 + ], + "score": 0.79, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 214, + 504, + 228 + ], + "score": 1.0, + "content": "is large, as is typically the case in images and other high-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 481, + 239 + ], + "score": 1.0, + "content": "dimensional spaces of interest, this linearity implies that even imperceptibly small values of", + "type": "text" + }, + { + "bbox": [ + 481, + 228, + 487, + 236 + ], + "score": 0.72, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "can", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 238, + 495, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 495, + 249 + ], + "score": 1.0, + "content": "have a large effect on the model’s prediction, making the model vulnerable to adversarial attacks.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5, + "bbox_fs": [ + 104, + 198, + 506, + 249 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 254, + 505, + 321 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 267 + ], + "score": 1.0, + "content": "Though neural networks in principle have the capacity to represent highly nonlinear functions, net-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "works trained via stochastic gradient descent on real-world datasets tend to converge to mostly-linear", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "solutions. This is illustrated in the empirical studies conducted by Goodfellow et al. (2014). One", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "hypothesis proposed to explain this phenomenon is that the nonlinearities typically used in networks", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "score": 1.0, + "content": "are either piecewise linear, like ReLUs, or approximately linear in the parts of their domain in which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 309, + 294, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 294, + 322 + ], + "score": 1.0, + "content": "training takes place, like the sigmoid function.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 254, + 505, + 322 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 505, + 415 + ], + "lines": [ + { + "bbox": [ + 107, + 327, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 107, + 327, + 505, + 338 + ], + "score": 1.0, + "content": "One potential solution to this problem is to use more non-linear activation functions, such as", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 337, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 350 + ], + "score": 1.0, + "content": "quadratic or RBF units. Indeed, it was shown by Goodfellow et al. (2014) that such units were", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "more resistant to adversarial perturbations of their inputs. However, these units are difficult to train,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 358, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 372 + ], + "score": 1.0, + "content": "and the resulting models do not generalize very well (Goodfellow et al., 2014), sacrificing accuracy", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "on clean examples. As an alternative to introducing highly non-linear activation functions in the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 381, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 506, + 393 + ], + "score": 1.0, + "content": "network, we propose applying a non-differentiable and non-linear transformation (discretization) to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 393, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 505, + 405 + ], + "score": 1.0, + "content": "the input, before passing it into the model. A comparison of the input to the model under various", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 403, + 499, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 499, + 416 + ], + "score": 1.0, + "content": "regimes can be seen in Figure 1, highlighting the strong non-linearity of discretization techniques.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 327, + 506, + 416 + ] + }, + { + "type": "image", + "bbox": [ + 117, + 438, + 492, + 583 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 117, + 438, + 492, + 583 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 438, + 492, + 583 + ], + "spans": [ + { + "bbox": [ + 117, + 438, + 492, + 583 + ], + "score": 0.969, + "type": "image", + "image_path": "1babc487bea1da3867ddd67e758440fd4bfd2a7dd066a336fbbff60b9365e8fd.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 117, + 438, + 492, + 486.3333333333333 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 117, + 486.3333333333333, + 492, + 534.6666666666666 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 117, + 534.6666666666666, + 492, + 583.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 506, + 713 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "Figure 1: Comparison of regular inputs, quantized inputs, and discretized inputs (16 levels, projected", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 604, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 328, + 616 + ], + "score": 1.0, + "content": "to one dimension) on MNIST, adversarially trained with", + "type": "text" + }, + { + "bbox": [ + 328, + 604, + 360, + 614 + ], + "score": 0.9, + "content": "\\varepsilon = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 604, + 381, + 616 + ], + "score": 1.0, + "content": ". The", + "type": "text" + }, + { + "bbox": [ + 382, + 605, + 389, + 613 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 604, + 506, + 616 + ], + "score": 1.0, + "content": "-axis represents the true pixel", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 615, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 215, + 626 + ], + "score": 1.0, + "content": "value of the image, and the", + "type": "text" + }, + { + "bbox": [ + 215, + 616, + 222, + 626 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 615, + 505, + 626 + ], + "score": 1.0, + "content": "-axis represents the value that is passed as input to the network after the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "score": 1.0, + "content": "input transformation has been applied. For real-valued inputs, the inputs to the network are affected", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 635, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 650 + ], + "score": 1.0, + "content": "linearly by perturbations to the input. Quantized inputs are also affected approximately linearly by", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 648, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 187, + 660 + ], + "score": 1.0, + "content": "perturbations where", + "type": "text" + }, + { + "bbox": [ + 187, + 649, + 194, + 657 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 648, + 506, + 660 + ], + "score": 1.0, + "content": "is greater than the bucket width. Discretizing the input, and then using learned", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "weights to project the discretized value back to a single scalar, we see that the model has learned", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 669, + 505, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 682 + ], + "score": 1.0, + "content": "a highly non-linear function to represent the input in a fashion that is effective for resisting the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "adversarial perturbations it has seen. When starting at the most common pixel-values for MNIST,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 690, + 506, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 690, + 298, + 705 + ], + "score": 1.0, + "content": "0 and 1, any perturbation of the pixels (where", + "type": "text" + }, + { + "bbox": [ + 298, + 692, + 335, + 703 + ], + "score": 0.87, + "content": "\\varepsilon \\le 0 . 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 690, + 506, + 705 + ], + "score": 1.0, + "content": ") has barely any effect on the input to the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 703, + 144, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 703, + 144, + 713 + ], + "score": 1.0, + "content": "network.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 34 + } + ], + "index": 30.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 248, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 249, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 249, + 95 + ], + "score": 1.0, + "content": "2.2 TYPES OF DISCRETIZATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 102, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 104, + 102, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 104, + 102, + 455, + 116 + ], + "score": 1.0, + "content": "In this work we consider two approaches to constructing discretized representations", + "type": "text" + }, + { + "bbox": [ + 455, + 103, + 476, + 115 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 102, + 505, + 116 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 156, + 126 + ], + "score": 1.0, + "content": "input image", + "type": "text" + }, + { + "bbox": [ + 157, + 116, + 163, + 124 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 114, + 378, + 126 + ], + "score": 1.0, + "content": ". Assume for the sake of simplicity that the entries of", + "type": "text" + }, + { + "bbox": [ + 378, + 116, + 385, + 124 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 114, + 505, + 126 + ], + "score": 1.0, + "content": "take values in the continuous", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 165, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 139, + 138 + ], + "score": 1.0, + "content": "domain", + "type": "text" + }, + { + "bbox": [ + 140, + 125, + 160, + 137 + ], + "score": 0.37, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 124, + 165, + 138 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 505, + 176 + ], + "lines": [ + { + "bbox": [ + 106, + 141, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 271, + 154 + ], + "score": 1.0, + "content": "We first describe a quantization function", + "type": "text" + }, + { + "bbox": [ + 272, + 142, + 277, + 152 + ], + "score": 0.63, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 141, + 314, + 154 + ], + "score": 1.0, + "content": ". Choose", + "type": "text" + }, + { + "bbox": [ + 315, + 142, + 435, + 153 + ], + "score": 0.9, + "content": "0 < b _ { 1 } < b _ { 2 } < \\cdot \\cdot \\cdot < b _ { k } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 141, + 505, + 154 + ], + "score": 1.0, + "content": "in some fashion.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 327, + 166 + ], + "score": 1.0, + "content": "(In this work, we simply divide the domain evenly, i.e.", + "type": "text" + }, + { + "bbox": [ + 327, + 153, + 357, + 165 + ], + "score": 0.88, + "content": "\\begin{array} { r } { b _ { i } = \\frac { i } { k } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 151, + 438, + 166 + ], + "score": 1.0, + "content": ".) For a real number", + "type": "text" + }, + { + "bbox": [ + 438, + 153, + 477, + 164 + ], + "score": 0.92, + "content": "\\theta \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 151, + 506, + 166 + ], + "score": 1.0, + "content": "define", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 163, + 352, + 177 + ], + "spans": [ + { + "bbox": [ + 107, + 164, + 124, + 176 + ], + "score": 0.9, + "content": "b ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 125, + 163, + 216, + 177 + ], + "score": 1.0, + "content": "to be the largest index", + "type": "text" + }, + { + "bbox": [ + 217, + 164, + 279, + 176 + ], + "score": 0.94, + "content": "\\alpha \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 163, + 318, + 177 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 318, + 164, + 347, + 175 + ], + "score": 0.92, + "content": "\\theta \\leq b _ { \\alpha }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 163, + 352, + 177 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "title", + "bbox": [ + 107, + 187, + 235, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 235, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 235, + 200 + ], + "score": 1.0, + "content": "2.2.1 ONE-HOT ENCODINGS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 205, + 451, + 219 + ], + "lines": [ + { + "bbox": [ + 104, + 204, + 453, + 221 + ], + "spans": [ + { + "bbox": [ + 104, + 204, + 159, + 221 + ], + "score": 1.0, + "content": "For an index", + "type": "text" + }, + { + "bbox": [ + 159, + 207, + 219, + 219 + ], + "score": 0.93, + "content": "j \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 204, + 233, + 221 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 233, + 206, + 277, + 219 + ], + "score": 0.93, + "content": "\\chi ( j ) \\in \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 204, + 425, + 221 + ], + "score": 1.0, + "content": "be the indicator or one-hot vector of", + "type": "text" + }, + { + "bbox": [ + 425, + 208, + 431, + 218 + ], + "score": 0.8, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 204, + 453, + 221 + ], + "score": 1.0, + "content": ", i.e.,", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "interline_equation", + "bbox": [ + 249, + 224, + 351, + 252 + ], + "lines": [ + { + "bbox": [ + 249, + 224, + 351, + 252 + ], + "spans": [ + { + "bbox": [ + 249, + 224, + 351, + 252 + ], + "score": 0.94, + "content": "\\chi ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l = j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "a0a8cf10e5403f6feb84714620930bbba19a668a7285e5844c11900acb928f21.jpg" + } + ] + } + ], + "index": 9.5, + "virtual_lines": [ + { + "bbox": [ + 249, + 224, + 351, + 238.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 249, + 238.0, + 351, + 252.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 257, + 419, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 255, + 420, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 344, + 272 + ], + "score": 1.0, + "content": "The discretization function is defined pixel-wise for a pixel", + "type": "text" + }, + { + "bbox": [ + 345, + 258, + 404, + 270 + ], + "score": 0.93, + "content": "i \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 255, + 420, + 272 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "interline_equation", + "bbox": [ + 254, + 273, + 357, + 288 + ], + "lines": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "spans": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "score": 0.9, + "content": "f _ { o n e h o t } ( x _ { i } ) = \\chi \\left( b ( x _ { i } ) \\right) .", + "type": "interline_equation", + "image_path": "7120442f434cd3b5836c11f3e981c529cbd07b32d00dd116bb2a9628a200dda8.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 292, + 506, + 348 + ], + "lines": [ + { + "bbox": [ + 106, + 293, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 505, + 305 + ], + "score": 1.0, + "content": "One-hot encodings are simple to compute and understand, and are often used when it is necessary to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "represent a categorical variable in a neural network. However, one-hot encodings are not well suited", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "for representing categorical variables with an interpretation of ordering between them. Note that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 323, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 273, + 340 + ], + "score": 1.0, + "content": "ordering information between two pixels", + "type": "text" + }, + { + "bbox": [ + 274, + 327, + 284, + 336 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 323, + 303, + 340 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 303, + 327, + 314, + 338 + ], + "score": 0.85, + "content": "x _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 323, + 470, + 340 + ], + "score": 1.0, + "content": "is lost by applying the transformation", + "type": "text" + }, + { + "bbox": [ + 470, + 326, + 501, + 337 + ], + "score": 0.84, + "content": "f _ { o n e h o t }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 323, + 506, + 340 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 336, + 335, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 182, + 349 + ], + "score": 1.0, + "content": "for a pair of pixels", + "type": "text" + }, + { + "bbox": [ + 183, + 337, + 196, + 348 + ], + "score": 0.88, + "content": "i , j", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 336, + 238, + 349 + ], + "score": 1.0, + "content": "whenever", + "type": "text" + }, + { + "bbox": [ + 239, + 336, + 298, + 349 + ], + "score": 0.91, + "content": "b ( x _ { i } ) \\neq b ( x _ { j } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 336, + 335, + 349 + ], + "score": 1.0, + "content": ", we see:", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15 + }, + { + "type": "interline_equation", + "bbox": [ + 237, + 352, + 374, + 367 + ], + "lines": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "spans": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "score": 0.92, + "content": "\\| \\chi ( b ( x _ { i } ) ) \\| _ { 2 } = \\| \\chi ( b ( x _ { j } ) ) \\| _ { 2 } = 1 .", + "type": "interline_equation", + "image_path": "b44c88d53fc42b7fe725319b69f778e994a772bb9ede8abd6ada74c76c621fef.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 371, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 384 + ], + "score": 1.0, + "content": "In the case of pixel values, this is not a good inductive bias, as there is a clear reason to believe that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 382, + 396, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 396, + 394 + ], + "score": 1.0, + "content": "neighboring buckets are more similar to each other than distant buckets.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 108, + 405, + 261, + 417 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 262, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 262, + 417 + ], + "score": 1.0, + "content": "2.2.2 THERMOMETER ENCODINGS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 424, + 505, + 458 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 255, + 438 + ], + "score": 1.0, + "content": "In order to discretize the input image", + "type": "text" + }, + { + "bbox": [ + 256, + 428, + 263, + 435 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 423, + 506, + 438 + ], + "score": 1.0, + "content": "without losing the relative distance information, we propose", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 264, + 448 + ], + "score": 1.0, + "content": "thermometer encodings. For an index", + "type": "text" + }, + { + "bbox": [ + 265, + 436, + 328, + 448 + ], + "score": 0.93, + "content": "j \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 435, + 346, + 448 + ], + "score": 1.0, + "content": ", let", + "type": "text" + }, + { + "bbox": [ + 347, + 435, + 393, + 448 + ], + "score": 0.93, + "content": "\\tau ( j ) \\in \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "be the thermometer vector", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 445, + 151, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 151, + 459 + ], + "score": 1.0, + "content": "defined as", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "interline_equation", + "bbox": [ + 249, + 462, + 350, + 490 + ], + "lines": [ + { + "bbox": [ + 249, + 462, + 350, + 490 + ], + "spans": [ + { + "bbox": [ + 249, + 462, + 350, + 490 + ], + "score": 0.93, + "content": "\\tau ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l \\geq j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "84aa81f1e2b0a9aabe126223a313095cfaaa857827c1581e4a23f74747c83572.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 249, + 462, + 350, + 476.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 249, + 476.0, + 350, + 490.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 447, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 448, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 236, + 509 + ], + "score": 1.0, + "content": "Then the discretization function", + "type": "text" + }, + { + "bbox": [ + 236, + 496, + 243, + 507 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 493, + 372, + 509 + ], + "score": 1.0, + "content": "is defined pixel-wise for a pixel", + "type": "text" + }, + { + "bbox": [ + 373, + 496, + 432, + 508 + ], + "score": 0.94, + "content": "i \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 493, + 448, + 509 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "interline_equation", + "bbox": [ + 219, + 512, + 391, + 526 + ], + "lines": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "spans": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "score": 0.87, + "content": "f _ { t h e r m } ( x ) _ { i } = \\tau \\left( b ( x _ { i } ) \\right) = \\mathbb { C } ( f _ { o n e h o t } ( x _ { i } ) )", + "type": "interline_equation", + "image_path": "cc78168d2a37525517d4fec8638194baa05ef1e5d63b516ddd50bf990dd17bcd.jpg" + } + ] + } + ], + "index": 28, + "virtual_lines": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 532, + 333, + 559 + ], + "lines": [ + { + "bbox": [ + 104, + 531, + 330, + 560 + ], + "spans": [ + { + "bbox": [ + 104, + 533, + 133, + 554 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 540, + 142, + 549 + ], + "score": 0.8, + "content": "\\mathbb { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 533, + 270, + 554 + ], + "score": 1.0, + "content": "is the cumulative sum function,", + "type": "text" + }, + { + "bbox": [ + 271, + 531, + 330, + 560 + ], + "score": 0.93, + "content": "\\mathbb { C } ( c ) _ { l } = \\sum _ { j = 0 } ^ { l } c _ { l }", + "type": "inline_equation" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 504, + 587 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 480, + 577 + ], + "score": 1.0, + "content": "Note that the thermometer encoding preserves pairwise ordering information, i.e., for pixels", + "type": "text" + }, + { + "bbox": [ + 481, + 565, + 495, + 576 + ], + "score": 0.89, + "content": "i , j", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "if", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 575, + 238, + 588 + ], + "spans": [ + { + "bbox": [ + 107, + 575, + 165, + 587 + ], + "score": 0.93, + "content": "b ( x _ { j } ) \\neq b ( x _ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 575, + 183, + 588 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 576, + 217, + 587 + ], + "score": 0.91, + "content": "x _ { i } < x _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 575, + 238, + 588 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "interline_equation", + "bbox": [ + 246, + 591, + 365, + 606 + ], + "lines": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "spans": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "score": 0.9, + "content": "\\left\\| \\tau ( b ( x _ { i } ) ) \\right\\| _ { 2 } < \\left\\| \\tau ( b ( x _ { j } ) ) \\right\\| _ { 2 } .", + "type": "interline_equation", + "image_path": "9b130f8646c68cc95bbceb99dc07dc16a382866069d43f165f94fead1751a38c.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "title", + "bbox": [ + 109, + 617, + 331, + 629 + ], + "lines": [ + { + "bbox": [ + 106, + 617, + 333, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 333, + 630 + ], + "score": 1.0, + "content": "2.3 WHITE-BOX ATTACKS ON DISCRETIZED INPUTS", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 504, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 504, + 649 + ], + "score": 1.0, + "content": "Discretizing the input makes it difficult to attack the model with standard white-box attack algo-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "rithms, such as FGSM (Goodfellow et al., 2014) and PGD (Madry et al., 2017), since it is impossible", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 659, + 504, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 504, + 672 + ], + "score": 1.0, + "content": "to backpropagate through our discretization function to determine how to adversarially modify the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "score": 1.0, + "content": "model’s input. In this section, we describe two novel iterative attacks which allow us to construct", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 681, + 363, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 363, + 694 + ], + "score": 1.0, + "content": "adversarial examples for networks trained on discretized inputs.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Constructing white-box attacks on discretized inputs serves two primary purposes. First, it allows", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "us to more completely evaluate whether the model is robust to all adversarial attacks, as white-box", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "attacks are typically more powerful than their black-box counterparts. Secondly, adversarial training", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 248, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 249, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 249, + 95 + ], + "score": 1.0, + "content": "2.2 TYPES OF DISCRETIZATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 102, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 104, + 102, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 104, + 102, + 455, + 116 + ], + "score": 1.0, + "content": "In this work we consider two approaches to constructing discretized representations", + "type": "text" + }, + { + "bbox": [ + 455, + 103, + 476, + 115 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 102, + 505, + 116 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 156, + 126 + ], + "score": 1.0, + "content": "input image", + "type": "text" + }, + { + "bbox": [ + 157, + 116, + 163, + 124 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 114, + 378, + 126 + ], + "score": 1.0, + "content": ". Assume for the sake of simplicity that the entries of", + "type": "text" + }, + { + "bbox": [ + 378, + 116, + 385, + 124 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 114, + 505, + 126 + ], + "score": 1.0, + "content": "take values in the continuous", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 124, + 165, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 124, + 139, + 138 + ], + "score": 1.0, + "content": "domain", + "type": "text" + }, + { + "bbox": [ + 140, + 125, + 160, + 137 + ], + "score": 0.37, + "content": "[ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 124, + 165, + 138 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 104, + 102, + 505, + 138 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 505, + 176 + ], + "lines": [ + { + "bbox": [ + 106, + 141, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 271, + 154 + ], + "score": 1.0, + "content": "We first describe a quantization function", + "type": "text" + }, + { + "bbox": [ + 272, + 142, + 277, + 152 + ], + "score": 0.63, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 141, + 314, + 154 + ], + "score": 1.0, + "content": ". Choose", + "type": "text" + }, + { + "bbox": [ + 315, + 142, + 435, + 153 + ], + "score": 0.9, + "content": "0 < b _ { 1 } < b _ { 2 } < \\cdot \\cdot \\cdot < b _ { k } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 141, + 505, + 154 + ], + "score": 1.0, + "content": "in some fashion.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 327, + 166 + ], + "score": 1.0, + "content": "(In this work, we simply divide the domain evenly, i.e.", + "type": "text" + }, + { + "bbox": [ + 327, + 153, + 357, + 165 + ], + "score": 0.88, + "content": "\\begin{array} { r } { b _ { i } = \\frac { i } { k } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 151, + 438, + 166 + ], + "score": 1.0, + "content": ".) For a real number", + "type": "text" + }, + { + "bbox": [ + 438, + 153, + 477, + 164 + ], + "score": 0.92, + "content": "\\theta \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 151, + 506, + 166 + ], + "score": 1.0, + "content": "define", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 163, + 352, + 177 + ], + "spans": [ + { + "bbox": [ + 107, + 164, + 124, + 176 + ], + "score": 0.9, + "content": "b ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 125, + 163, + 216, + 177 + ], + "score": 1.0, + "content": "to be the largest index", + "type": "text" + }, + { + "bbox": [ + 217, + 164, + 279, + 176 + ], + "score": 0.94, + "content": "\\alpha \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 163, + 318, + 177 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 318, + 164, + 347, + 175 + ], + "score": 0.92, + "content": "\\theta \\leq b _ { \\alpha }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 163, + 352, + 177 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 141, + 506, + 177 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 187, + 235, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 235, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 235, + 200 + ], + "score": 1.0, + "content": "2.2.1 ONE-HOT ENCODINGS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 205, + 451, + 219 + ], + "lines": [ + { + "bbox": [ + 104, + 204, + 453, + 221 + ], + "spans": [ + { + "bbox": [ + 104, + 204, + 159, + 221 + ], + "score": 1.0, + "content": "For an index", + "type": "text" + }, + { + "bbox": [ + 159, + 207, + 219, + 219 + ], + "score": 0.93, + "content": "j \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 204, + 233, + 221 + ], + "score": 1.0, + "content": "let", + "type": "text" + }, + { + "bbox": [ + 233, + 206, + 277, + 219 + ], + "score": 0.93, + "content": "\\chi ( j ) \\in \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 204, + 425, + 221 + ], + "score": 1.0, + "content": "be the indicator or one-hot vector of", + "type": "text" + }, + { + "bbox": [ + 425, + 208, + 431, + 218 + ], + "score": 0.8, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 204, + 453, + 221 + ], + "score": 1.0, + "content": ", i.e.,", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 104, + 204, + 453, + 221 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 249, + 224, + 351, + 252 + ], + "lines": [ + { + "bbox": [ + 249, + 224, + 351, + 252 + ], + "spans": [ + { + "bbox": [ + 249, + 224, + 351, + 252 + ], + "score": 0.94, + "content": "\\chi ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l = j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "a0a8cf10e5403f6feb84714620930bbba19a668a7285e5844c11900acb928f21.jpg" + } + ] + } + ], + "index": 9.5, + "virtual_lines": [ + { + "bbox": [ + 249, + 224, + 351, + 238.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 249, + 238.0, + 351, + 252.0 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 257, + 419, + 270 + ], + "lines": [ + { + "bbox": [ + 105, + 255, + 420, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 344, + 272 + ], + "score": 1.0, + "content": "The discretization function is defined pixel-wise for a pixel", + "type": "text" + }, + { + "bbox": [ + 345, + 258, + 404, + 270 + ], + "score": 0.93, + "content": "i \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 255, + 420, + 272 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 255, + 420, + 272 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 254, + 273, + 357, + 288 + ], + "lines": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "spans": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "score": 0.9, + "content": "f _ { o n e h o t } ( x _ { i } ) = \\chi \\left( b ( x _ { i } ) \\right) .", + "type": "interline_equation", + "image_path": "7120442f434cd3b5836c11f3e981c529cbd07b32d00dd116bb2a9628a200dda8.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 254, + 273, + 357, + 288 + ], + "spans": [], + "index": 12 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 292, + 506, + 348 + ], + "lines": [ + { + "bbox": [ + 106, + 293, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 505, + 305 + ], + "score": 1.0, + "content": "One-hot encodings are simple to compute and understand, and are often used when it is necessary to", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "represent a categorical variable in a neural network. However, one-hot encodings are not well suited", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "for representing categorical variables with an interpretation of ordering between them. Note that the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 323, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 273, + 340 + ], + "score": 1.0, + "content": "ordering information between two pixels", + "type": "text" + }, + { + "bbox": [ + 274, + 327, + 284, + 336 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 323, + 303, + 340 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 303, + 327, + 314, + 338 + ], + "score": 0.85, + "content": "x _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 323, + 470, + 340 + ], + "score": 1.0, + "content": "is lost by applying the transformation", + "type": "text" + }, + { + "bbox": [ + 470, + 326, + 501, + 337 + ], + "score": 0.84, + "content": "f _ { o n e h o t }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 323, + 506, + 340 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 336, + 335, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 182, + 349 + ], + "score": 1.0, + "content": "for a pair of pixels", + "type": "text" + }, + { + "bbox": [ + 183, + 337, + 196, + 348 + ], + "score": 0.88, + "content": "i , j", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 336, + 238, + 349 + ], + "score": 1.0, + "content": "whenever", + "type": "text" + }, + { + "bbox": [ + 239, + 336, + 298, + 349 + ], + "score": 0.91, + "content": "b ( x _ { i } ) \\neq b ( x _ { j } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 336, + 335, + 349 + ], + "score": 1.0, + "content": ", we see:", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 293, + 506, + 349 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 237, + 352, + 374, + 367 + ], + "lines": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "spans": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "score": 0.92, + "content": "\\| \\chi ( b ( x _ { i } ) ) \\| _ { 2 } = \\| \\chi ( b ( x _ { j } ) ) \\| _ { 2 } = 1 .", + "type": "interline_equation", + "image_path": "b44c88d53fc42b7fe725319b69f778e994a772bb9ede8abd6ada74c76c621fef.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 237, + 352, + 374, + 367 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 371, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 506, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 384 + ], + "score": 1.0, + "content": "In the case of pixel values, this is not a good inductive bias, as there is a clear reason to believe that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 382, + 396, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 396, + 394 + ], + "score": 1.0, + "content": "neighboring buckets are more similar to each other than distant buckets.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 370, + 506, + 394 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 405, + 261, + 417 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 262, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 262, + 417 + ], + "score": 1.0, + "content": "2.2.2 THERMOMETER ENCODINGS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 424, + 505, + 458 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 255, + 438 + ], + "score": 1.0, + "content": "In order to discretize the input image", + "type": "text" + }, + { + "bbox": [ + 256, + 428, + 263, + 435 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 423, + 506, + 438 + ], + "score": 1.0, + "content": "without losing the relative distance information, we propose", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 264, + 448 + ], + "score": 1.0, + "content": "thermometer encodings. For an index", + "type": "text" + }, + { + "bbox": [ + 265, + 436, + 328, + 448 + ], + "score": 0.93, + "content": "j \\in \\{ 1 , \\ldots , k \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 435, + 346, + 448 + ], + "score": 1.0, + "content": ", let", + "type": "text" + }, + { + "bbox": [ + 347, + 435, + 393, + 448 + ], + "score": 0.93, + "content": "\\tau ( j ) \\in \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "be the thermometer vector", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 445, + 151, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 151, + 459 + ], + "score": 1.0, + "content": "defined as", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 423, + 506, + 459 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 249, + 462, + 350, + 490 + ], + "lines": [ + { + "bbox": [ + 249, + 462, + 350, + 490 + ], + "spans": [ + { + "bbox": [ + 249, + 462, + 350, + 490 + ], + "score": 0.93, + "content": "\\tau ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l \\geq j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "84aa81f1e2b0a9aabe126223a313095cfaaa857827c1581e4a23f74747c83572.jpg" + } + ] + } + ], + "index": 25.5, + "virtual_lines": [ + { + "bbox": [ + 249, + 462, + 350, + 476.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 249, + 476.0, + 350, + 490.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 447, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 493, + 448, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 236, + 509 + ], + "score": 1.0, + "content": "Then the discretization function", + "type": "text" + }, + { + "bbox": [ + 236, + 496, + 243, + 507 + ], + "score": 0.87, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 493, + 372, + 509 + ], + "score": 1.0, + "content": "is defined pixel-wise for a pixel", + "type": "text" + }, + { + "bbox": [ + 373, + 496, + 432, + 508 + ], + "score": 0.94, + "content": "i \\in \\{ 1 , \\ldots , n \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 493, + 448, + 509 + ], + "score": 1.0, + "content": "as:", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 493, + 448, + 509 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 219, + 512, + 391, + 526 + ], + "lines": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "spans": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "score": 0.87, + "content": "f _ { t h e r m } ( x ) _ { i } = \\tau \\left( b ( x _ { i } ) \\right) = \\mathbb { C } ( f _ { o n e h o t } ( x _ { i } ) )", + "type": "interline_equation", + "image_path": "cc78168d2a37525517d4fec8638194baa05ef1e5d63b516ddd50bf990dd17bcd.jpg" + } + ] + } + ], + "index": 28, + "virtual_lines": [ + { + "bbox": [ + 219, + 512, + 391, + 526 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 532, + 333, + 559 + ], + "lines": [ + { + "bbox": [ + 104, + 531, + 330, + 560 + ], + "spans": [ + { + "bbox": [ + 104, + 533, + 133, + 554 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 540, + 142, + 549 + ], + "score": 0.8, + "content": "\\mathbb { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 533, + 270, + 554 + ], + "score": 1.0, + "content": "is the cumulative sum function,", + "type": "text" + }, + { + "bbox": [ + 271, + 531, + 330, + 560 + ], + "score": 0.93, + "content": "\\mathbb { C } ( c ) _ { l } = \\sum _ { j = 0 } ^ { l } c _ { l }", + "type": "inline_equation" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 531, + 330, + 560 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 504, + 587 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 480, + 577 + ], + "score": 1.0, + "content": "Note that the thermometer encoding preserves pairwise ordering information, i.e., for pixels", + "type": "text" + }, + { + "bbox": [ + 481, + 565, + 495, + 576 + ], + "score": 0.89, + "content": "i , j", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "if", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 107, + 575, + 238, + 588 + ], + "spans": [ + { + "bbox": [ + 107, + 575, + 165, + 587 + ], + "score": 0.93, + "content": "b ( x _ { j } ) \\neq b ( x _ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 575, + 183, + 588 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 576, + 217, + 587 + ], + "score": 0.91, + "content": "x _ { i } < x _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 575, + 238, + 588 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 563, + 506, + 588 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 246, + 591, + 365, + 606 + ], + "lines": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "spans": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "score": 0.9, + "content": "\\left\\| \\tau ( b ( x _ { i } ) ) \\right\\| _ { 2 } < \\left\\| \\tau ( b ( x _ { j } ) ) \\right\\| _ { 2 } .", + "type": "interline_equation", + "image_path": "9b130f8646c68cc95bbceb99dc07dc16a382866069d43f165f94fead1751a38c.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 246, + 591, + 365, + 606 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "title", + "bbox": [ + 109, + 617, + 331, + 629 + ], + "lines": [ + { + "bbox": [ + 106, + 617, + 333, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 333, + 630 + ], + "score": 1.0, + "content": "2.3 WHITE-BOX ATTACKS ON DISCRETIZED INPUTS", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 504, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 504, + 649 + ], + "score": 1.0, + "content": "Discretizing the input makes it difficult to attack the model with standard white-box attack algo-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "rithms, such as FGSM (Goodfellow et al., 2014) and PGD (Madry et al., 2017), since it is impossible", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 659, + 504, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 504, + 672 + ], + "score": 1.0, + "content": "to backpropagate through our discretization function to determine how to adversarially modify the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 506, + 683 + ], + "score": 1.0, + "content": "model’s input. In this section, we describe two novel iterative attacks which allow us to construct", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 681, + 363, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 363, + 694 + ], + "score": 1.0, + "content": "adversarial examples for networks trained on discretized inputs.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 637, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 698, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Constructing white-box attacks on discretized inputs serves two primary purposes. First, it allows", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "us to more completely evaluate whether the model is robust to all adversarial attacks, as white-box", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "attacks are typically more powerful than their black-box counterparts. Secondly, adversarial training", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "is typically performed in a white-box fashion, and so in order to utilize and properly compare against", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "the adversarial training techniques of Madry et al. (2017), it is important to have strong white-box", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 140, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 140, + 117 + ], + "score": 1.0, + "content": "attacks.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 698, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "is typically performed in a white-box fashion, and so in order to utilize and properly compare against", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 106 + ], + "score": 1.0, + "content": "the adversarial training techniques of Madry et al. (2017), it is important to have strong white-box", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 140, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 140, + 117 + ], + "score": 1.0, + "content": "attacks.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 380, + 133 + ], + "score": 1.0, + "content": "For ease of presentation, we will describe the attacks assuming that", + "type": "text" + }, + { + "bbox": [ + 380, + 120, + 432, + 133 + ], + "score": 0.93, + "content": "f : \\mathbb { R } \\to \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 120, + 505, + 133 + ], + "score": 1.0, + "content": "discretizes inputs", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "into thermometer encodings; in order to attack one-hot encodings, simply replace all instances of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 107, + 144, + 136, + 155 + ], + "score": 0.57, + "content": "f _ { t h e r m }", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 144, + 159, + 155 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 159, + 144, + 190, + 155 + ], + "score": 0.74, + "content": "f _ { o n e h o t }", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 144, + 194, + 155 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 195, + 145, + 202, + 154 + ], + "score": 0.62, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 144, + 225, + 155 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 225, + 145, + 233, + 155 + ], + "score": 0.79, + "content": "\\chi", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 144, + 255, + 155 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 256, + 144, + 264, + 153 + ], + "score": 0.72, + "content": "\\mathbb { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "with the identity function I. We represent the adversarial", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 151, + 410, + 169 + ], + "spans": [ + { + "bbox": [ + 104, + 151, + 154, + 169 + ], + "score": 1.0, + "content": "image after", + "type": "text" + }, + { + "bbox": [ + 154, + 155, + 159, + 164 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 151, + 245, + 169 + ], + "score": 1.0, + "content": "steps of the attack as", + "type": "text" + }, + { + "bbox": [ + 245, + 154, + 255, + 164 + ], + "score": 0.87, + "content": "z ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 151, + 394, + 169 + ], + "score": 1.0, + "content": ", where the value of the ith pixel is", + "type": "text" + }, + { + "bbox": [ + 395, + 154, + 404, + 167 + ], + "score": 0.88, + "content": "z _ { i } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 151, + 410, + 169 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 170, + 505, + 249 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 504, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 504, + 182 + ], + "score": 1.0, + "content": "The first attack, Discrete Gradient Ascent (DGA), follows the direction of the gradient of the loss", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 167, + 195 + ], + "score": 1.0, + "content": "with respect to", + "type": "text" + }, + { + "bbox": [ + 167, + 182, + 187, + 194 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 182, + 505, + 195 + ], + "score": 1.0, + "content": ", but is constrained at every step to be a discretized vector. If we have discretized", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 192, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 189, + 207 + ], + "score": 1.0, + "content": "the input image into", + "type": "text" + }, + { + "bbox": [ + 189, + 194, + 196, + 203 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 192, + 506, + 207 + ], + "score": 1.0, + "content": "-dimensional vectors using the one-hot encoding, this corresponds to moving", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 212, + 217 + ], + "score": 1.0, + "content": "to a vertex of the simplex", + "type": "text" + }, + { + "bbox": [ + 212, + 204, + 239, + 216 + ], + "score": 0.92, + "content": "\\left( \\Delta _ { k } \\right) ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "at every step. The second attack, Logit-Space Projected Gradient", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 227 + ], + "score": 1.0, + "content": "Ascent (LS-PGA), relaxes this assumption, allowing intermediate iterates to be in the interior of the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "simplex. The final adversarial image is obtained by projecting the final point back to the nearest", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 236, + 195, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 195, + 250 + ], + "score": 1.0, + "content": "vertex of the simplex.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 108, + 253, + 503, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "score": 1.0, + "content": "Note that if the number of attack steps is 1, then the two attacks are equivalent; however, for larger", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 264, + 354, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 354, + 277 + ], + "score": 1.0, + "content": "numbers of attack steps, LS-PGA is a generalization of DGA.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 108, + 290, + 303, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 304, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 304, + 304 + ], + "score": 1.0, + "content": "2.3.1 DISCRETE GRADIENT ASCENT (DGA)", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 309, + 504, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 506, + 323 + ], + "score": 1.0, + "content": "Following PGD (Madry et al., 2017), we initialize DGA by placing each pixel into a random bucket", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 162, + 334 + ], + "score": 1.0, + "content": "that is within", + "type": "text" + }, + { + "bbox": [ + 162, + 323, + 168, + 331 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 320, + 505, + 334 + ], + "score": 1.0, + "content": "of the pixel’s true value. At each step of the attack, we look at all buckets that are", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 331, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 134, + 345 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 135, + 334, + 141, + 342 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 331, + 505, + 345 + ], + "score": 1.0, + "content": "of the true value, and select the bucket that is likely to do the most ‘harm’, as estimated by", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 343, + 506, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 506, + 356 + ], + "score": 1.0, + "content": "the gradient of setting that bucket’s indicator variable to 1, with respect to the model’s loss at the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 354, + 163, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 163, + 367 + ], + "score": 1.0, + "content": "previous step.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19 + }, + { + "type": "interline_equation", + "bbox": [ + 145, + 370, + 464, + 439 + ], + "lines": [ + { + "bbox": [ + 145, + 370, + 464, + 439 + ], + "spans": [ + { + "bbox": [ + 145, + 370, + 464, + 439 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { z _ { i } ^ { 0 } = f _ { t h e r m } ( x _ { i } + U ( - \\varepsilon , \\varepsilon ) ) } \\\\ & { \\mathrm { h a r m } ( z _ { i } ^ { t } ) _ { l } = \\left\\{ \\begin{array} { l l } { ( z _ { i } ^ { t } - \\tau ( l ) ) ^ { \\top } \\cdot \\frac { \\partial \\mathbb { L } ( z ^ { t } ) } { \\partial z _ { i } ^ { t } } } & { \\mathrm { i f } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { 0 } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\qquad z _ { i } ^ { t + 1 } = \\tau \\left( \\mathrm { a r g } \\operatorname* { m a x } \\left( \\mathrm { h a r m } \\left( z _ { i } ^ { t } \\right) \\right) \\right) } \\end{array}", + "type": "interline_equation", + "image_path": "0a8a21f923068660d20d6e41ce5c5f4ac9a273637073b0fe64cbfa4a794de862.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 145, + 370, + 464, + 393.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 145, + 393.0, + 464, + 416.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 145, + 416.0, + 464, + 439.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 442, + 502, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 504, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 504, + 456 + ], + "score": 1.0, + "content": "Because the outcome of this optimization procedure will vary depending on the initial random per-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 454, + 504, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 504, + 466 + ], + "score": 1.0, + "content": "turbation, we suggest strengthening the attack by re-running it several times and using the pertur-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 468, + 478 + ], + "score": 1.0, + "content": "bation with the greatest loss. The pseudo-code for the DGA attack is given in Section", + "type": "text" + }, + { + "bbox": [ + 468, + 465, + 477, + 475 + ], + "score": 0.29, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 477, + 149, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 149, + 488 + ], + "score": 1.0, + "content": "appendix.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "title", + "bbox": [ + 107, + 500, + 385, + 513 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 386, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 386, + 514 + ], + "score": 1.0, + "content": "2.3.2 LOGIT-SPACE PROJECTED GRADIENT ASCENT (LS-PGA)", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 609 + ], + "lines": [ + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "To perform LS-PGA, we soften the discrete encodings into continuous relaxations, and then perform", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "standard Projected Gradient Ascent (PGA) on these relaxed values. We represent the distribution", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 280, + 556 + ], + "score": 1.0, + "content": "over embeddings as a softmax over logits", + "type": "text" + }, + { + "bbox": [ + 281, + 545, + 287, + 553 + ], + "score": 0.66, + "content": "u", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 543, + 505, + 556 + ], + "score": 1.0, + "content": ", each corresponding to the unnormalized log-weight", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 492, + 567 + ], + "score": 1.0, + "content": "of a specific bucket’s embedding. To improve the attack, we scale the logits with temperature", + "type": "text" + }, + { + "bbox": [ + 493, + 555, + 501, + 564 + ], + "score": 0.73, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 554, + 505, + 567 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "allowing us to trade off between how closely our softmax approximates a true one-hot distribution", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "as in the Gumbel-softmax trick (Jang et al., 2016; Maddison et al., 2016), and how much gradient", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "signal the logits receive. At each step of a multi-step attack, we anneal this value via exponential", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 598, + 180, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 170, + 610 + ], + "score": 1.0, + "content": "decay with rate", + "type": "text" + }, + { + "bbox": [ + 170, + 599, + 176, + 608 + ], + "score": 0.73, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 598, + 180, + 610 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5 + }, + { + "type": "interline_equation", + "bbox": [ + 239, + 616, + 372, + 681 + ], + "lines": [ + { + "bbox": [ + 239, + 616, + 372, + 681 + ], + "spans": [ + { + "bbox": [ + 239, + 616, + 372, + 681 + ], + "score": 0.94, + "content": "\\begin{array} { c } { { z _ { i } ^ { t } = \\mathbb C \\left( \\sigma \\left( \\frac { u _ { i } ^ { t } } { T ^ { t } } \\right) \\right) } } \\\\ { { z _ { i } ^ { f i n a l } = \\tau \\left( \\arg \\operatorname* { m a x } \\left( u _ { i } ^ { f i n a l } \\right) \\right) } } \\\\ { { T ^ { t } = T ^ { t - 1 } \\cdot \\delta } } \\end{array}", + "type": "interline_equation", + "image_path": "8917ac99edcaeb487851b70ae3d860f7005fc8a09d79157fe4763000b60e0529.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 239, + 616, + 372, + 648.5 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 239, + 648.5, + 372, + 681.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "We initialize each of the logits randomly with values sampled from a standard normal distribution.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "At each step, we ensure that the model does not assign any probability to buckets which are not", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 134, + 721 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 134, + 711, + 140, + 720 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 710, + 305, + 721 + ], + "score": 1.0, + "content": "of the true value by fixing the logits to be", + "type": "text" + }, + { + "bbox": [ + 306, + 713, + 324, + 720 + ], + "score": 0.82, + "content": "- \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 710, + 506, + 721 + ], + "score": 1.0, + "content": ". The model’s loss is a continuous function of", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "the logits, so we can simply utilize attacks designed for continuous-valued inputs, in this case PGA", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 41.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 115 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 380, + 133 + ], + "score": 1.0, + "content": "For ease of presentation, we will describe the attacks assuming that", + "type": "text" + }, + { + "bbox": [ + 380, + 120, + 432, + 133 + ], + "score": 0.93, + "content": "f : \\mathbb { R } \\to \\mathbb { R } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 120, + 505, + 133 + ], + "score": 1.0, + "content": "discretizes inputs", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "into thermometer encodings; in order to attack one-hot encodings, simply replace all instances of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 107, + 144, + 136, + 155 + ], + "score": 0.57, + "content": "f _ { t h e r m }", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 144, + 159, + 155 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 159, + 144, + 190, + 155 + ], + "score": 0.74, + "content": "f _ { o n e h o t }", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 144, + 194, + 155 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 195, + 145, + 202, + 154 + ], + "score": 0.62, + "content": "\\tau", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 144, + 225, + 155 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 225, + 145, + 233, + 155 + ], + "score": 0.79, + "content": "\\chi", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 144, + 255, + 155 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 256, + 144, + 264, + 153 + ], + "score": 0.72, + "content": "\\mathbb { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "with the identity function I. We represent the adversarial", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 151, + 410, + 169 + ], + "spans": [ + { + "bbox": [ + 104, + 151, + 154, + 169 + ], + "score": 1.0, + "content": "image after", + "type": "text" + }, + { + "bbox": [ + 154, + 155, + 159, + 164 + ], + "score": 0.78, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 151, + 245, + 169 + ], + "score": 1.0, + "content": "steps of the attack as", + "type": "text" + }, + { + "bbox": [ + 245, + 154, + 255, + 164 + ], + "score": 0.87, + "content": "z ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 151, + 394, + 169 + ], + "score": 1.0, + "content": ", where the value of the ith pixel is", + "type": "text" + }, + { + "bbox": [ + 395, + 154, + 404, + 167 + ], + "score": 0.88, + "content": "z _ { i } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 151, + 410, + 169 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5, + "bbox_fs": [ + 104, + 120, + 506, + 169 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 170, + 505, + 249 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 504, + 182 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 504, + 182 + ], + "score": 1.0, + "content": "The first attack, Discrete Gradient Ascent (DGA), follows the direction of the gradient of the loss", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 167, + 195 + ], + "score": 1.0, + "content": "with respect to", + "type": "text" + }, + { + "bbox": [ + 167, + 182, + 187, + 194 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 182, + 505, + 195 + ], + "score": 1.0, + "content": ", but is constrained at every step to be a discretized vector. If we have discretized", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 192, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 189, + 207 + ], + "score": 1.0, + "content": "the input image into", + "type": "text" + }, + { + "bbox": [ + 189, + 194, + 196, + 203 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 192, + 506, + 207 + ], + "score": 1.0, + "content": "-dimensional vectors using the one-hot encoding, this corresponds to moving", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 212, + 217 + ], + "score": 1.0, + "content": "to a vertex of the simplex", + "type": "text" + }, + { + "bbox": [ + 212, + 204, + 239, + 216 + ], + "score": 0.92, + "content": "\\left( \\Delta _ { k } \\right) ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 240, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "at every step. The second attack, Logit-Space Projected Gradient", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 227 + ], + "score": 1.0, + "content": "Ascent (LS-PGA), relaxes this assumption, allowing intermediate iterates to be in the interior of the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "simplex. The final adversarial image is obtained by projecting the final point back to the nearest", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 236, + 195, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 195, + 250 + ], + "score": 1.0, + "content": "vertex of the simplex.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 171, + 506, + 250 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 253, + 503, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 504, + 267 + ], + "score": 1.0, + "content": "Note that if the number of attack steps is 1, then the two attacks are equivalent; however, for larger", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 264, + 354, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 354, + 277 + ], + "score": 1.0, + "content": "numbers of attack steps, LS-PGA is a generalization of DGA.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 253, + 504, + 277 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 290, + 303, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 288, + 304, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 304, + 304 + ], + "score": 1.0, + "content": "2.3.1 DISCRETE GRADIENT ASCENT (DGA)", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 309, + 504, + 365 + ], + "lines": [ + { + "bbox": [ + 105, + 309, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 506, + 323 + ], + "score": 1.0, + "content": "Following PGD (Madry et al., 2017), we initialize DGA by placing each pixel into a random bucket", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 320, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 162, + 334 + ], + "score": 1.0, + "content": "that is within", + "type": "text" + }, + { + "bbox": [ + 162, + 323, + 168, + 331 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 320, + 505, + 334 + ], + "score": 1.0, + "content": "of the pixel’s true value. At each step of the attack, we look at all buckets that are", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 331, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 134, + 345 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 135, + 334, + 141, + 342 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 331, + 505, + 345 + ], + "score": 1.0, + "content": "of the true value, and select the bucket that is likely to do the most ‘harm’, as estimated by", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 343, + 506, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 506, + 356 + ], + "score": 1.0, + "content": "the gradient of setting that bucket’s indicator variable to 1, with respect to the model’s loss at the", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 354, + 163, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 163, + 367 + ], + "score": 1.0, + "content": "previous step.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 309, + 506, + 367 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 145, + 370, + 464, + 439 + ], + "lines": [ + { + "bbox": [ + 145, + 370, + 464, + 439 + ], + "spans": [ + { + "bbox": [ + 145, + 370, + 464, + 439 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { z _ { i } ^ { 0 } = f _ { t h e r m } ( x _ { i } + U ( - \\varepsilon , \\varepsilon ) ) } \\\\ & { \\mathrm { h a r m } ( z _ { i } ^ { t } ) _ { l } = \\left\\{ \\begin{array} { l l } { ( z _ { i } ^ { t } - \\tau ( l ) ) ^ { \\top } \\cdot \\frac { \\partial \\mathbb { L } ( z ^ { t } ) } { \\partial z _ { i } ^ { t } } } & { \\mathrm { i f } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { 0 } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\qquad z _ { i } ^ { t + 1 } = \\tau \\left( \\mathrm { a r g } \\operatorname* { m a x } \\left( \\mathrm { h a r m } \\left( z _ { i } ^ { t } \\right) \\right) \\right) } \\end{array}", + "type": "interline_equation", + "image_path": "0a8a21f923068660d20d6e41ce5c5f4ac9a273637073b0fe64cbfa4a794de862.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 145, + 370, + 464, + 393.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 145, + 393.0, + 464, + 416.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 145, + 416.0, + 464, + 439.0 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 442, + 502, + 487 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 504, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 504, + 456 + ], + "score": 1.0, + "content": "Because the outcome of this optimization procedure will vary depending on the initial random per-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 454, + 504, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 504, + 466 + ], + "score": 1.0, + "content": "turbation, we suggest strengthening the attack by re-running it several times and using the pertur-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 464, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 468, + 478 + ], + "score": 1.0, + "content": "bation with the greatest loss. The pseudo-code for the DGA attack is given in Section", + "type": "text" + }, + { + "bbox": [ + 468, + 465, + 477, + 475 + ], + "score": 0.29, + "content": "\\mathbf { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 464, + 505, + 478 + ], + "score": 1.0, + "content": "of the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 477, + 149, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 149, + 488 + ], + "score": 1.0, + "content": "appendix.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 442, + 505, + 488 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 500, + 385, + 513 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 386, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 386, + 514 + ], + "score": 1.0, + "content": "2.3.2 LOGIT-SPACE PROJECTED GRADIENT ASCENT (LS-PGA)", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 609 + ], + "lines": [ + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "To perform LS-PGA, we soften the discrete encodings into continuous relaxations, and then perform", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "standard Projected Gradient Ascent (PGA) on these relaxed values. We represent the distribution", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 280, + 556 + ], + "score": 1.0, + "content": "over embeddings as a softmax over logits", + "type": "text" + }, + { + "bbox": [ + 281, + 545, + 287, + 553 + ], + "score": 0.66, + "content": "u", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 543, + 505, + 556 + ], + "score": 1.0, + "content": ", each corresponding to the unnormalized log-weight", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 492, + 567 + ], + "score": 1.0, + "content": "of a specific bucket’s embedding. To improve the attack, we scale the logits with temperature", + "type": "text" + }, + { + "bbox": [ + 493, + 555, + 501, + 564 + ], + "score": 0.73, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 554, + 505, + 567 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "allowing us to trade off between how closely our softmax approximates a true one-hot distribution", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "as in the Gumbel-softmax trick (Jang et al., 2016; Maddison et al., 2016), and how much gradient", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "signal the logits receive. At each step of a multi-step attack, we anneal this value via exponential", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 598, + 180, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 170, + 610 + ], + "score": 1.0, + "content": "decay with rate", + "type": "text" + }, + { + "bbox": [ + 170, + 599, + 176, + 608 + ], + "score": 0.73, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 598, + 180, + 610 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 521, + 505, + 610 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 239, + 616, + 372, + 681 + ], + "lines": [ + { + "bbox": [ + 239, + 616, + 372, + 681 + ], + "spans": [ + { + "bbox": [ + 239, + 616, + 372, + 681 + ], + "score": 0.94, + "content": "\\begin{array} { c } { { z _ { i } ^ { t } = \\mathbb C \\left( \\sigma \\left( \\frac { u _ { i } ^ { t } } { T ^ { t } } \\right) \\right) } } \\\\ { { z _ { i } ^ { f i n a l } = \\tau \\left( \\arg \\operatorname* { m a x } \\left( u _ { i } ^ { f i n a l } \\right) \\right) } } \\\\ { { T ^ { t } = T ^ { t - 1 } \\cdot \\delta } } \\end{array}", + "type": "interline_equation", + "image_path": "8917ac99edcaeb487851b70ae3d860f7005fc8a09d79157fe4763000b60e0529.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 239, + 616, + 372, + 648.5 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 239, + 648.5, + 372, + 681.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "We initialize each of the logits randomly with values sampled from a standard normal distribution.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "At each step, we ensure that the model does not assign any probability to buckets which are not", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 710, + 506, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 134, + 721 + ], + "score": 1.0, + "content": "within", + "type": "text" + }, + { + "bbox": [ + 134, + 711, + 140, + 720 + ], + "score": 0.73, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 710, + 305, + 721 + ], + "score": 1.0, + "content": "of the true value by fixing the logits to be", + "type": "text" + }, + { + "bbox": [ + 306, + 713, + 324, + 720 + ], + "score": 0.82, + "content": "- \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 710, + 506, + 721 + ], + "score": 1.0, + "content": ". The model’s loss is a continuous function of", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "the logits, so we can simply utilize attacks designed for continuous-valued inputs, in this case PGA", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 686, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 173, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 174, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 164, + 96 + ], + "score": 1.0, + "content": "with step-size", + "type": "text" + }, + { + "bbox": [ + 164, + 83, + 170, + 94 + ], + "score": 0.83, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 81, + 174, + 96 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 101, + 469, + 166 + ], + "lines": [ + { + "bbox": [ + 141, + 101, + 469, + 166 + ], + "spans": [ + { + "bbox": [ + 141, + 101, + 469, + 166 + ], + "score": 0.89, + "content": "\\begin{array} { r l } & { u _ { i } ^ { 0 } = \\left\\{ \\begin{array} { l l } { N \\left( \\mathbf { 0 } ; \\mathbf { 1 } \\right) } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\left( u _ { i } ^ { t + 1 } \\right) _ { l } = \\left\\{ \\begin{array} { l l } { \\left( u _ { i } ^ { t } \\right) _ { l } + \\xi \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } \\left( z ^ { t } \\right) } { \\partial u _ { i } ^ { t } } \\right) _ { l } } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\end{array}", + "type": "interline_equation", + "image_path": "4a8fd676fc209c58ef9dabe4a2d06491fa344a4cc4e2548805ffffbec81b3b7a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 141, + 101, + 469, + 122.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 141, + 122.66666666666667, + 469, + 144.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 141, + 144.33333333333334, + 469, + 166.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 186, + 504, + 220 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "Because the outcome of this optimization procedure will vary depending on the initial perturbation,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "we suggest strengthening the attack by re-running it several times and using the perturbation with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 209, + 491, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 491, + 221 + ], + "score": 1.0, + "content": "the greatest loss. The pseudo-code for the LS-PGA attack is given in Section B of the appendix.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "title", + "bbox": [ + 108, + 238, + 200, + 250 + ], + "lines": [ + { + "bbox": [ + 104, + 236, + 202, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 236, + 202, + 253 + ], + "score": 1.0, + "content": "3 EXPERIMENTS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "score": 1.0, + "content": "We compare models trained with input discretization to state-of-the-art adversarial defenses on a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "score": 1.0, + "content": "variety of datasets. We match the experimental setup of the prior literature as closely as possible.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "Rows labeled with “Vanilla (Madry)” give the numbers reported in Madry et al. (2017); other rows", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "contain results of our own experiments, with “Vanilla” containing a direct replication. For our", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "MNIST experiments, we use a convolutional network; for CIFAR-10, CIFAR-100, and SVHN we", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "use a Wide ResNet (Zagoruyko & Komodakis, 2016). We use a network of depth 30 for the CIFAR-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "10 and CIFAR-100 datasets, while for SVHN we use a network of depth 15. The width factor of all", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 212, + 353 + ], + "score": 1.0, + "content": "the Wide ResNets is set to", + "type": "text" + }, + { + "bbox": [ + 212, + 341, + 237, + 351 + ], + "score": 0.89, + "content": "k = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 340, + 505, + 353 + ], + "score": 1.0, + "content": ". 1 Unless otherwise specified, all quantized and discretized models", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 352, + 162, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 162, + 363 + ], + "score": 1.0, + "content": "use 16 levels.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 368, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 367, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 504, + 381 + ], + "score": 1.0, + "content": "We found that in all cases, LS-PGA was strictly more powerful than DGA, so all attacks on dis-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 247, + 392 + ], + "score": 1.0, + "content": "cretized models use LS-PGA with", + "type": "text" + }, + { + "bbox": [ + 247, + 380, + 322, + 391 + ], + "score": 0.92, + "content": "\\xi = 0 . 0 1 , \\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 380, + 505, + 392 + ], + "score": 1.0, + "content": ", and 1 random restart. To be consistent with", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 380, + 403 + ], + "score": 1.0, + "content": "Madry et al. (2017), we describe attacks in terms of the maximum", + "type": "text" + }, + { + "bbox": [ + 380, + 391, + 394, + 402 + ], + "score": 0.89, + "content": "\\ell _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 390, + 477, + 403 + ], + "score": 1.0, + "content": "-norm of the attack,", + "type": "text" + }, + { + "bbox": [ + 477, + 393, + 483, + 401 + ], + "score": 0.58, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 390, + 505, + 403 + ], + "score": 1.0, + "content": ". All", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 213, + 414 + ], + "score": 1.0, + "content": "MNIST experiments used", + "type": "text" + }, + { + "bbox": [ + 213, + 402, + 248, + 412 + ], + "score": 0.89, + "content": "\\varepsilon = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "and 40 steps for iterative attacks; experiments on CIFAR used", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 151, + 423 + ], + "score": 0.88, + "content": "\\varepsilon = 0 . 0 3 1", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 412, + 404, + 425 + ], + "score": 1.0, + "content": "and 7 steps for iterative attacks; experiments on SVHN used", + "type": "text" + }, + { + "bbox": [ + 405, + 413, + 450, + 423 + ], + "score": 0.87, + "content": "\\varepsilon = 0 . 0 4 7", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "and 10 steps", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "for iterative attacks. These settings were used for adversarial training, white-box attacks, and black-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "box attacks. Figure 3 plots the effectiveness of the iterated PGD/LS-PGA attacks on vanilla and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 446, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 505, + 457 + ], + "score": 1.0, + "content": "discretized models for MNIST and shows that increasing the number of iterations beyond 40 would", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 456, + 498, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 309, + 468 + ], + "score": 1.0, + "content": "have no effect on the performance of the model on", + "type": "text" + }, + { + "bbox": [ + 310, + 456, + 324, + 467 + ], + "score": 0.89, + "content": "\\ell _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 456, + 498, + 468 + ], + "score": 1.0, + "content": "-bounded adversarial examples for MNIST.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 473, + 505, + 561 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 504, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 504, + 485 + ], + "score": 1.0, + "content": "In Madry et al. (2017), adversarially-trained models are trained using exclusively adversarial inputs.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 484, + 504, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 439, + 497 + ], + "score": 1.0, + "content": "This led to a small but noticeable loss in accuracy on clean examples, dropping from", + "type": "text" + }, + { + "bbox": [ + 439, + 484, + 466, + 495 + ], + "score": 0.85, + "content": "9 9 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 484, + 477, + 497 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 477, + 484, + 504, + 495 + ], + "score": 0.85, + "content": "9 8 . 8 \\%", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 495, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 189, + 506 + ], + "score": 1.0, + "content": "on MNIST and from", + "type": "text" + }, + { + "bbox": [ + 189, + 495, + 216, + 506 + ], + "score": 0.87, + "content": "9 5 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 495, + 226, + 506 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 227, + 495, + 254, + 506 + ], + "score": 0.89, + "content": "8 7 . 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 495, + 505, + 506 + ], + "score": 1.0, + "content": "on CIFAR-10 in return for more robustness towards adversarial", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "examples. Past work has also sometimes performed adversarial training on batches composed of half", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "clean examples and half adversarial examples (Goodfellow et al., 2014; Cisse et al., 2017). To be", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "consistent with Madry et al. (2017), we list experiments on models trained only on adversarial inputs", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 539, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 506, + 552 + ], + "score": 1.0, + "content": "in the main paper; additional experiments on a mix of clean and adversarial inputs can be found in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 549, + 164, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 164, + 564 + ], + "score": 1.0, + "content": "the appendix.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "We also run experiments exploring the model’s relationship with the number of distinct levels to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "score": 1.0, + "content": "which we quantize the input before discretizing it, and exploring various settings of hyperparameters", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 589, + 160, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 160, + 599 + ], + "score": 1.0, + "content": "for LS-PGA.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "title", + "bbox": [ + 107, + 618, + 172, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 617, + 174, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 174, + 632 + ], + "score": 1.0, + "content": "4 RESULTS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "score": 1.0, + "content": "Our adversarially-trained baseline models were able to approximately replicate the results of Madry", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "score": 1.0, + "content": "et al. (2017). On all datasets, discretizing the inputs of the network dramatically improves resistance", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "to adversarial examples, while barely sacrificing any accuracy on clean examples. Quantized models", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "also beat the baseline, but with lower accuracy on clean examples. Discretization via thermometer", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 688, + 504, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 504, + 699 + ], + "score": 1.0, + "content": "encodings outperformed one-hot encodings in most settings. See Tables 2,3,4 and 5 for results on", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "score": 1.0, + "content": "MNIST and CIFAR-10. Additional results on CIFAR-100 and SVHN are included in the appendix.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 113, + 721, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "1A full list of hyperparameters can be found in the appendix. Source code is available at http://anonymized", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 173, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 174, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 164, + 96 + ], + "score": 1.0, + "content": "with step-size", + "type": "text" + }, + { + "bbox": [ + 164, + 83, + 170, + 94 + ], + "score": 0.83, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 81, + 174, + 96 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0, + "bbox_fs": [ + 106, + 81, + 174, + 96 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 141, + 101, + 469, + 166 + ], + "lines": [ + { + "bbox": [ + 141, + 101, + 469, + 166 + ], + "spans": [ + { + "bbox": [ + 141, + 101, + 469, + 166 + ], + "score": 0.89, + "content": "\\begin{array} { r l } & { u _ { i } ^ { 0 } = \\left\\{ \\begin{array} { l l } { N \\left( \\mathbf { 0 } ; \\mathbf { 1 } \\right) } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\left( u _ { i } ^ { t + 1 } \\right) _ { l } = \\left\\{ \\begin{array} { l l } { \\left( u _ { i } ^ { t } \\right) _ { l } + \\xi \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } \\left( z ^ { t } \\right) } { \\partial u _ { i } ^ { t } } \\right) _ { l } } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\end{array}", + "type": "interline_equation", + "image_path": "4a8fd676fc209c58ef9dabe4a2d06491fa344a4cc4e2548805ffffbec81b3b7a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 141, + 101, + 469, + 122.66666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 141, + 122.66666666666667, + 469, + 144.33333333333334 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 141, + 144.33333333333334, + 469, + 166.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 186, + 504, + 220 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 200 + ], + "score": 1.0, + "content": "Because the outcome of this optimization procedure will vary depending on the initial perturbation,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "we suggest strengthening the attack by re-running it several times and using the perturbation with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 209, + 491, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 209, + 491, + 221 + ], + "score": 1.0, + "content": "the greatest loss. The pseudo-code for the LS-PGA attack is given in Section B of the appendix.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 186, + 505, + 221 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 238, + 200, + 250 + ], + "lines": [ + { + "bbox": [ + 104, + 236, + 202, + 253 + ], + "spans": [ + { + "bbox": [ + 104, + 236, + 202, + 253 + ], + "score": 1.0, + "content": "3 EXPERIMENTS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 263, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "score": 1.0, + "content": "We compare models trained with input discretization to state-of-the-art adversarial defenses on a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 504, + 288 + ], + "score": 1.0, + "content": "variety of datasets. We match the experimental setup of the prior literature as closely as possible.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "Rows labeled with “Vanilla (Madry)” give the numbers reported in Madry et al. (2017); other rows", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 309 + ], + "score": 1.0, + "content": "contain results of our own experiments, with “Vanilla” containing a direct replication. For our", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "MNIST experiments, we use a convolutional network; for CIFAR-10, CIFAR-100, and SVHN we", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 504, + 331 + ], + "score": 1.0, + "content": "use a Wide ResNet (Zagoruyko & Komodakis, 2016). We use a network of depth 30 for the CIFAR-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "10 and CIFAR-100 datasets, while for SVHN we use a network of depth 15. The width factor of all", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 212, + 353 + ], + "score": 1.0, + "content": "the Wide ResNets is set to", + "type": "text" + }, + { + "bbox": [ + 212, + 341, + 237, + 351 + ], + "score": 0.89, + "content": "k = 4", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 340, + 505, + 353 + ], + "score": 1.0, + "content": ". 1 Unless otherwise specified, all quantized and discretized models", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 352, + 162, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 162, + 363 + ], + "score": 1.0, + "content": "use 16 levels.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 263, + 506, + 363 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 368, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 367, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 504, + 381 + ], + "score": 1.0, + "content": "We found that in all cases, LS-PGA was strictly more powerful than DGA, so all attacks on dis-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 380, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 247, + 392 + ], + "score": 1.0, + "content": "cretized models use LS-PGA with", + "type": "text" + }, + { + "bbox": [ + 247, + 380, + 322, + 391 + ], + "score": 0.92, + "content": "\\xi = 0 . 0 1 , \\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 380, + 505, + 392 + ], + "score": 1.0, + "content": ", and 1 random restart. To be consistent with", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 380, + 403 + ], + "score": 1.0, + "content": "Madry et al. (2017), we describe attacks in terms of the maximum", + "type": "text" + }, + { + "bbox": [ + 380, + 391, + 394, + 402 + ], + "score": 0.89, + "content": "\\ell _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 390, + 477, + 403 + ], + "score": 1.0, + "content": "-norm of the attack,", + "type": "text" + }, + { + "bbox": [ + 477, + 393, + 483, + 401 + ], + "score": 0.58, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 390, + 505, + 403 + ], + "score": 1.0, + "content": ". All", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 213, + 414 + ], + "score": 1.0, + "content": "MNIST experiments used", + "type": "text" + }, + { + "bbox": [ + 213, + 402, + 248, + 412 + ], + "score": 0.89, + "content": "\\varepsilon = 0 . 3", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "and 40 steps for iterative attacks; experiments on CIFAR used", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 151, + 423 + ], + "score": 0.88, + "content": "\\varepsilon = 0 . 0 3 1", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 412, + 404, + 425 + ], + "score": 1.0, + "content": "and 7 steps for iterative attacks; experiments on SVHN used", + "type": "text" + }, + { + "bbox": [ + 405, + 413, + 450, + 423 + ], + "score": 0.87, + "content": "\\varepsilon = 0 . 0 4 7", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "and 10 steps", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "for iterative attacks. These settings were used for adversarial training, white-box attacks, and black-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 505, + 447 + ], + "score": 1.0, + "content": "box attacks. Figure 3 plots the effectiveness of the iterated PGD/LS-PGA attacks on vanilla and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 446, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 505, + 457 + ], + "score": 1.0, + "content": "discretized models for MNIST and shows that increasing the number of iterations beyond 40 would", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 456, + 498, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 309, + 468 + ], + "score": 1.0, + "content": "have no effect on the performance of the model on", + "type": "text" + }, + { + "bbox": [ + 310, + 456, + 324, + 467 + ], + "score": 0.89, + "content": "\\ell _ { \\infty }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 456, + 498, + 468 + ], + "score": 1.0, + "content": "-bounded adversarial examples for MNIST.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 367, + 506, + 468 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 473, + 505, + 561 + ], + "lines": [ + { + "bbox": [ + 105, + 473, + 504, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 504, + 485 + ], + "score": 1.0, + "content": "In Madry et al. (2017), adversarially-trained models are trained using exclusively adversarial inputs.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 484, + 504, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 439, + 497 + ], + "score": 1.0, + "content": "This led to a small but noticeable loss in accuracy on clean examples, dropping from", + "type": "text" + }, + { + "bbox": [ + 439, + 484, + 466, + 495 + ], + "score": 0.85, + "content": "9 9 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 484, + 477, + 497 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 477, + 484, + 504, + 495 + ], + "score": 0.85, + "content": "9 8 . 8 \\%", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 495, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 189, + 506 + ], + "score": 1.0, + "content": "on MNIST and from", + "type": "text" + }, + { + "bbox": [ + 189, + 495, + 216, + 506 + ], + "score": 0.87, + "content": "9 5 . 2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 495, + 226, + 506 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 227, + 495, + 254, + 506 + ], + "score": 0.89, + "content": "8 7 . 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 495, + 505, + 506 + ], + "score": 1.0, + "content": "on CIFAR-10 in return for more robustness towards adversarial", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "examples. Past work has also sometimes performed adversarial training on batches composed of half", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "clean examples and half adversarial examples (Goodfellow et al., 2014; Cisse et al., 2017). To be", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "consistent with Madry et al. (2017), we list experiments on models trained only on adversarial inputs", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 539, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 506, + 552 + ], + "score": 1.0, + "content": "in the main paper; additional experiments on a mix of clean and adversarial inputs can be found in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 549, + 164, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 164, + 564 + ], + "score": 1.0, + "content": "the appendix.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 473, + 506, + 564 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 600 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "We also run experiments exploring the model’s relationship with the number of distinct levels to", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 591 + ], + "score": 1.0, + "content": "which we quantize the input before discretizing it, and exploring various settings of hyperparameters", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 589, + 160, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 160, + 599 + ], + "score": 1.0, + "content": "for LS-PGA.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 567, + 505, + 599 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 618, + 172, + 630 + ], + "lines": [ + { + "bbox": [ + 105, + 617, + 174, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 174, + 632 + ], + "score": 1.0, + "content": "4 RESULTS", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "score": 1.0, + "content": "Our adversarially-trained baseline models were able to approximately replicate the results of Madry", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 668 + ], + "score": 1.0, + "content": "et al. (2017). On all datasets, discretizing the inputs of the network dramatically improves resistance", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "to adversarial examples, while barely sacrificing any accuracy on clean examples. Quantized models", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "also beat the baseline, but with lower accuracy on clean examples. Discretization via thermometer", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 688, + 504, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 504, + 699 + ], + "score": 1.0, + "content": "encodings outperformed one-hot encodings in most settings. See Tables 2,3,4 and 5 for results on", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 504, + 711 + ], + "score": 1.0, + "content": "MNIST and CIFAR-10. Additional results on CIFAR-100 and SVHN are included in the appendix.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 644, + 506, + 711 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "In Figures 2 and 5 (located in appendix), we plot the test-set accuracy across training timesteps for", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "various adversarially trained models on the SVHN and CIFAR-10 datasets, and observe that the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 418, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 418, + 118 + ], + "score": 1.0, + "content": "discretized models become robust against adversarial examples more quickly.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table", + "bbox": [ + 181, + 125, + 429, + 254 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 181, + 125, + 429, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 125, + 429, + 254 + ], + "spans": [ + { + "bbox": [ + 181, + 125, + 429, + 254 + ], + "score": 0.976, + "html": "
ModelCleanFGSMPGD/LS-PGA
ereaaVanilla (Madry)VanillaQuantizedOne-hotThermometer99.2099.3099.1999.1399.206.40-0000
0.191.1000
Y1nit aptVanilla (Madry)VanillaQuantizedOne-hotThermometer98.8098.6798.7598.6199.0395.6096.1796.2993.2093.3094.2394.3094.02
96.22
95.84
", + "type": "table", + "image_path": "cb8cb5a8b640a5bea75041a868f04f94e323b622d4b2dc7e358fd11b80638f03.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 181, + 125, + 429, + 168.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 181, + 168.0, + 429, + 211.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 181, + 211.0, + 429, + 254.0 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 144, + 262, + 465, + 274 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 261, + 466, + 275 + ], + "spans": [ + { + "bbox": [ + 144, + 261, + 466, + 275 + ], + "score": 1.0, + "content": "Table 2: Comparison of adversarial robustness to white-box attacks on MNIST .", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + } + ], + "index": 5.0 + }, + { + "type": "table", + "bbox": [ + 107, + 289, + 525, + 418 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 289, + 525, + 418 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 289, + 525, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 289, + 525, + 418 + ], + "score": 0.981, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
EreaaVanilla Quantized One-hot2.0436.0224.583.4880.4457.69
39.2232.3925.6375.0275.9252.32
14.576.918.1139.0239.6018.02
11p1l ApvThermometer Vanilla (Madry)41.1214.3010.9861.8459.1632.93
=196.0=1
Quantized97.6598.1697.1495.27 95.3196.53
Vanilla One-hot97.6298.0597.06 95.4395.3896.23
97.7898.4897.8796.8796.6096.87
Thermometer 98.0798.7598.0297.0596.8897.13
", + "type": "table", + "image_path": "cf2125c8de0866bf3201652f2cdb15f7a09d33b83a3bd403b6a14005255dcd8b.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 107, + 289, + 525, + 332.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 332.0, + 525, + 375.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 107, + 375.0, + 525, + 418.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 144, + 426, + 464, + 438 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 143, + 425, + 465, + 439 + ], + "spans": [ + { + "bbox": [ + 143, + 425, + 465, + 439 + ], + "score": 1.0, + "content": "Table 3: Comparison of adversarial robustness to black-box attacks on MNIST .", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "table", + "bbox": [ + 181, + 453, + 429, + 582 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 181, + 453, + 429, + 582 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 181, + 453, + 429, + 582 + ], + "spans": [ + { + "bbox": [ + 181, + 453, + 429, + 582 + ], + "score": 0.975, + "html": "
ModelCleanFGSMPGD/LS-PGA
eeeaaVanilla (Madry)VanillaQuantizedOne-hotThermometer95.2094.2993.4993.2694.2225.104.101.663.5753.1150.50
46.1543.8952.0748.50
11p11 'ApvVanilla (Madry)VanillaQuantizedOne-hotThermometer87.387.6785.7588.6789.8860.359.753.5368.7680.9650.041.7842.0967.8379.16
", + "type": "table", + "image_path": "0bb15de51702965b8a72d0eb8eb00226b0ad620898e95f8b30f37bb26550c3c2.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 181, + 453, + 429, + 496.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 181, + 496.0, + 429, + 539.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 181, + 539.0, + 429, + 582.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 136, + 591, + 469, + 603 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 137, + 590, + 471, + 603 + ], + "spans": [ + { + "bbox": [ + 137, + 590, + 471, + 603 + ], + "score": 1.0, + "content": "Table 4: Comparison of adversarial robustness to white-box attacks on CIFAR-10 .", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + } + ], + "index": 13.0 + }, + { + "type": "title", + "bbox": [ + 107, + 623, + 191, + 637 + ], + "lines": [ + { + "bbox": [ + 104, + 622, + 192, + 640 + ], + "spans": [ + { + "bbox": [ + 104, + 622, + 192, + 640 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "In Goodfellow et al. (2014), the seeming linearity of deep neural networks was shown by visualizing", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "the networks in several different ways. To test our hypothesis that discretization breaks some of this", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "linearity, we replicate these visualizations and contrast them to visualizations of discretized models.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 681, + 325, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 325, + 694 + ], + "score": 1.0, + "content": "See Appendix G for an illustration of these properties.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "For non-discretized, clean trained models, test-set examples always yield a linear boundary between", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "correct and incorrect classification; in contrast, non-adversarially-trained models have a more inter-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 721, + 259, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 259, + 733 + ], + "score": 1.0, + "content": "esting parabolic shape (see Figure 9).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 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": [ + 107, + 82, + 505, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "In Figures 2 and 5 (located in appendix), we plot the test-set accuracy across training timesteps for", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "various adversarially trained models on the SVHN and CIFAR-10 datasets, and observe that the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 418, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 418, + 118 + ], + "score": 1.0, + "content": "discretized models become robust against adversarial examples more quickly.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 118 + ] + }, + { + "type": "table", + "bbox": [ + 181, + 125, + 429, + 254 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 181, + 125, + 429, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 125, + 429, + 254 + ], + "spans": [ + { + "bbox": [ + 181, + 125, + 429, + 254 + ], + "score": 0.976, + "html": "
ModelCleanFGSMPGD/LS-PGA
ereaaVanilla (Madry)VanillaQuantizedOne-hotThermometer99.2099.3099.1999.1399.206.40-0000
0.191.1000
Y1nit aptVanilla (Madry)VanillaQuantizedOne-hotThermometer98.8098.6798.7598.6199.0395.6096.1796.2993.2093.3094.2394.3094.02
96.22
95.84
", + "type": "table", + "image_path": "cb8cb5a8b640a5bea75041a868f04f94e323b622d4b2dc7e358fd11b80638f03.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 181, + 125, + 429, + 168.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 181, + 168.0, + 429, + 211.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 181, + 211.0, + 429, + 254.0 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 144, + 262, + 465, + 274 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 144, + 261, + 466, + 275 + ], + "spans": [ + { + "bbox": [ + 144, + 261, + 466, + 275 + ], + "score": 1.0, + "content": "Table 2: Comparison of adversarial robustness to white-box attacks on MNIST .", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + } + ], + "index": 5.0 + }, + { + "type": "table", + "bbox": [ + 107, + 289, + 525, + 418 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 289, + 525, + 418 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 289, + 525, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 289, + 525, + 418 + ], + "score": 0.981, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
EreaaVanilla Quantized One-hot2.0436.0224.583.4880.4457.69
39.2232.3925.6375.0275.9252.32
14.576.918.1139.0239.6018.02
11p1l ApvThermometer Vanilla (Madry)41.1214.3010.9861.8459.1632.93
=196.0=1
Quantized97.6598.1697.1495.27 95.3196.53
Vanilla One-hot97.6298.0597.06 95.4395.3896.23
97.7898.4897.8796.8796.6096.87
Thermometer 98.0798.7598.0297.0596.8897.13
", + "type": "table", + "image_path": "cf2125c8de0866bf3201652f2cdb15f7a09d33b83a3bd403b6a14005255dcd8b.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 107, + 289, + 525, + 332.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 332.0, + 525, + 375.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 107, + 375.0, + 525, + 418.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 144, + 426, + 464, + 438 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 143, + 425, + 465, + 439 + ], + "spans": [ + { + "bbox": [ + 143, + 425, + 465, + 439 + ], + "score": 1.0, + "content": "Table 3: Comparison of adversarial robustness to black-box attacks on MNIST .", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + } + ], + "index": 9.0 + }, + { + "type": "table", + "bbox": [ + 181, + 453, + 429, + 582 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 181, + 453, + 429, + 582 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 181, + 453, + 429, + 582 + ], + "spans": [ + { + "bbox": [ + 181, + 453, + 429, + 582 + ], + "score": 0.975, + "html": "
ModelCleanFGSMPGD/LS-PGA
eeeaaVanilla (Madry)VanillaQuantizedOne-hotThermometer95.2094.2993.4993.2694.2225.104.101.663.5753.1150.50
46.1543.8952.0748.50
11p11 'ApvVanilla (Madry)VanillaQuantizedOne-hotThermometer87.387.6785.7588.6789.8860.359.753.5368.7680.9650.041.7842.0967.8379.16
", + "type": "table", + "image_path": "0bb15de51702965b8a72d0eb8eb00226b0ad620898e95f8b30f37bb26550c3c2.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 181, + 453, + 429, + 496.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 181, + 496.0, + 429, + 539.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 181, + 539.0, + 429, + 582.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 136, + 591, + 469, + 603 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 137, + 590, + 471, + 603 + ], + "spans": [ + { + "bbox": [ + 137, + 590, + 471, + 603 + ], + "score": 1.0, + "content": "Table 4: Comparison of adversarial robustness to white-box attacks on CIFAR-10 .", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + } + ], + "index": 13.0 + }, + { + "type": "title", + "bbox": [ + 107, + 623, + 191, + 637 + ], + "lines": [ + { + "bbox": [ + 104, + 622, + 192, + 640 + ], + "spans": [ + { + "bbox": [ + 104, + 622, + 192, + 640 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "In Goodfellow et al. (2014), the seeming linearity of deep neural networks was shown by visualizing", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "the networks in several different ways. To test our hypothesis that discretization breaks some of this", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "linearity, we replicate these visualizations and contrast them to visualizations of discretized models.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 681, + 325, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 325, + 694 + ], + "score": 1.0, + "content": "See Appendix G for an illustration of these properties.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 648, + 505, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "For non-discretized, clean trained models, test-set examples always yield a linear boundary between", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "correct and incorrect classification; in contrast, non-adversarially-trained models have a more inter-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 721, + 259, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 259, + 733 + ], + "score": 1.0, + "content": "esting parabolic shape (see Figure 9).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 525, + 220 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 525, + 220 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 525, + 220 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 525, + 220 + ], + "score": 0.982, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
evaaVanilla (Madry)0.01179.711
Vanilla3.3860.1052.6045.4837.2149.91
Quantized70.5462.4655.3851.7445.3755.64
One-hot83.0056.2563.9454.5949.2157.28
11pl apaThermometer Vanilla (Madry)80.3366.2253.4557.0451.0360.90
85.601167.011
Vanilla85.6074.9973.7867.050.0971.03
Quantized84.5682.4382.2272.5272.2979.43
One-hot Thermometer86.01 88.2577.19 81.5977.70 80.8061.92 67.9660.02 67.4372.89 77.68
", + "type": "table", + "image_path": "6a2369281a6b9b07fba7eeae0503af9c6467d64c0e47c8bd53930a9543661f21.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 525, + 126.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 126.66666666666666, + 525, + 173.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 173.33333333333331, + 525, + 219.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 140, + 228, + 470, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 139, + 227, + 472, + 240 + ], + "spans": [ + { + "bbox": [ + 139, + 227, + 472, + 240 + ], + "score": 1.0, + "content": "Table 5: Comparison of adversarial robustness to black-box attacks on CIFAR-10 .", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 107, + 268, + 473, + 396 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 268, + 473, + 396 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 268, + 473, + 396 + ], + "spans": [ + { + "bbox": [ + 107, + 268, + 473, + 396 + ], + "score": 0.852, + "type": "image", + "image_path": "2bf62500dea56cf3c5583933ce283039d15429aef2ff7e82327b7f820baa6c41.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 107, + 268, + 473, + 310.6666666666667 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 310.6666666666667, + 473, + 353.33333333333337 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 353.33333333333337, + 473, + 396.00000000000006 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 405, + 504, + 427 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 418 + ], + "score": 1.0, + "content": "Figure 2: Comparison of the convergence rate of various adversarially trained models on the SVHN", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 415, + 140, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 140, + 427 + ], + "score": 1.0, + "content": "dataset.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + } + ], + "index": 6.25 + }, + { + "type": "image", + "bbox": [ + 108, + 456, + 469, + 584 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 456, + 469, + 584 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 456, + 469, + 584 + ], + "spans": [ + { + "bbox": [ + 108, + 456, + 469, + 584 + ], + "score": 0.723, + "type": "image", + "image_path": "7bd4936771b204f572b896b319647e0cafa645e72147b75f92d688d6fe438bbe.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 456, + 469, + 498.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 498.6666666666667, + 469, + 541.3333333333334 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 541.3333333333334, + 469, + 584.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 504, + 626 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "Figure 3: Loss for iterated white-box attacks on various models on a randomly chosen data point", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "from MNIST. By step 40, which is where we evaluate, the loss of the point found by iterative attacks", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 614, + 168, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 168, + 627 + ], + "score": 1.0, + "content": "has converged.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 280, + 678 + ], + "score": 1.0, + "content": "When discretizing the input, we introduce", + "type": "text" + }, + { + "bbox": [ + 280, + 666, + 386, + 677 + ], + "score": 0.91, + "content": "C _ { w } \\cdot C _ { h } \\cdot C _ { o } \\cdot c \\cdot ( k - 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 665, + 488, + 678 + ], + "score": 1.0, + "content": "extra parameters, where", + "type": "text" + }, + { + "bbox": [ + 489, + 668, + 494, + 676 + ], + "score": 0.77, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 674, + 504, + 691 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 262, + 691 + ], + "score": 1.0, + "content": "the number of channels in the image,", + "type": "text" + }, + { + "bbox": [ + 262, + 677, + 269, + 687 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 674, + 456, + 691 + ], + "score": 1.0, + "content": "is the number of levels of discretization, and", + "type": "text" + }, + { + "bbox": [ + 456, + 677, + 504, + 688 + ], + "score": 0.92, + "content": "C _ { w } , C _ { h } , C _ { o }", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "are the width, height, and output channels of the first convolutional layer. Discretizing using 16", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 178, + 711 + ], + "score": 1.0, + "content": "levels introduced", + "type": "text" + }, + { + "bbox": [ + 178, + 699, + 206, + 709 + ], + "score": 0.88, + "content": "0 . 0 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 699, + 328, + 711 + ], + "score": 1.0, + "content": "extra parameters for MNIST,", + "type": "text" + }, + { + "bbox": [ + 329, + 699, + 356, + 709 + ], + "score": 0.87, + "content": "0 . 0 8 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "for CIFAR-10 and CIFAR-100, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 129, + 720 + ], + "score": 0.87, + "content": "2 . 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "for SVHN. This increase is negligible, so it is likely that the robustness comes from the input", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 719, + 460, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 460, + 733 + ], + "score": 1.0, + "content": "discretization, and is not merely a byproduct of having a slightly higher-capacity model.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 525, + 220 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 525, + 220 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 525, + 220 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 525, + 220 + ], + "score": 0.982, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
evaaVanilla (Madry)0.01179.711
Vanilla3.3860.1052.6045.4837.2149.91
Quantized70.5462.4655.3851.7445.3755.64
One-hot83.0056.2563.9454.5949.2157.28
11pl apaThermometer Vanilla (Madry)80.3366.2253.4557.0451.0360.90
85.601167.011
Vanilla85.6074.9973.7867.050.0971.03
Quantized84.5682.4382.2272.5272.2979.43
One-hot Thermometer86.01 88.2577.19 81.5977.70 80.8061.92 67.9660.02 67.4372.89 77.68
", + "type": "table", + "image_path": "6a2369281a6b9b07fba7eeae0503af9c6467d64c0e47c8bd53930a9543661f21.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 525, + 126.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 126.66666666666666, + 525, + 173.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 173.33333333333331, + 525, + 219.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 140, + 228, + 470, + 240 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 139, + 227, + 472, + 240 + ], + "spans": [ + { + "bbox": [ + 139, + 227, + 472, + 240 + ], + "score": 1.0, + "content": "Table 5: Comparison of adversarial robustness to black-box attacks on CIFAR-10 .", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 107, + 268, + 473, + 396 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 268, + 473, + 396 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 268, + 473, + 396 + ], + "spans": [ + { + "bbox": [ + 107, + 268, + 473, + 396 + ], + "score": 0.852, + "type": "image", + "image_path": "2bf62500dea56cf3c5583933ce283039d15429aef2ff7e82327b7f820baa6c41.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 107, + 268, + 473, + 310.6666666666667 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 107, + 310.6666666666667, + 473, + 353.33333333333337 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 107, + 353.33333333333337, + 473, + 396.00000000000006 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 405, + 504, + 427 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 418 + ], + "score": 1.0, + "content": "Figure 2: Comparison of the convergence rate of various adversarially trained models on the SVHN", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 415, + 140, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 140, + 427 + ], + "score": 1.0, + "content": "dataset.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + } + ], + "index": 6.25 + }, + { + "type": "image", + "bbox": [ + 108, + 456, + 469, + 584 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 456, + 469, + 584 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 456, + 469, + 584 + ], + "spans": [ + { + "bbox": [ + 108, + 456, + 469, + 584 + ], + "score": 0.723, + "type": "image", + "image_path": "7bd4936771b204f572b896b319647e0cafa645e72147b75f92d688d6fe438bbe.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 108, + 456, + 469, + 498.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 498.6666666666667, + 469, + 541.3333333333334 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 541.3333333333334, + 469, + 584.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 504, + 626 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "Figure 3: Loss for iterated white-box attacks on various models on a randomly chosen data point", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 505, + 615 + ], + "score": 1.0, + "content": "from MNIST. By step 40, which is where we evaluate, the loss of the point found by iterative attacks", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 614, + 168, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 168, + 627 + ], + "score": 1.0, + "content": "has converged.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 280, + 678 + ], + "score": 1.0, + "content": "When discretizing the input, we introduce", + "type": "text" + }, + { + "bbox": [ + 280, + 666, + 386, + 677 + ], + "score": 0.91, + "content": "C _ { w } \\cdot C _ { h } \\cdot C _ { o } \\cdot c \\cdot ( k - 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 665, + 488, + 678 + ], + "score": 1.0, + "content": "extra parameters, where", + "type": "text" + }, + { + "bbox": [ + 489, + 668, + 494, + 676 + ], + "score": 0.77, + "content": "c", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 674, + 504, + 691 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 262, + 691 + ], + "score": 1.0, + "content": "the number of channels in the image,", + "type": "text" + }, + { + "bbox": [ + 262, + 677, + 269, + 687 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 674, + 456, + 691 + ], + "score": 1.0, + "content": "is the number of levels of discretization, and", + "type": "text" + }, + { + "bbox": [ + 456, + 677, + 504, + 688 + ], + "score": 0.92, + "content": "C _ { w } , C _ { h } , C _ { o }", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "are the width, height, and output channels of the first convolutional layer. Discretizing using 16", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 178, + 711 + ], + "score": 1.0, + "content": "levels introduced", + "type": "text" + }, + { + "bbox": [ + 178, + 699, + 206, + 709 + ], + "score": 0.88, + "content": "0 . 0 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 699, + 328, + 711 + ], + "score": 1.0, + "content": "extra parameters for MNIST,", + "type": "text" + }, + { + "bbox": [ + 329, + 699, + 356, + 709 + ], + "score": 0.87, + "content": "0 . 0 8 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "for CIFAR-10 and CIFAR-100, and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 129, + 720 + ], + "score": 0.87, + "content": "2 . 3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "for SVHN. This increase is negligible, so it is likely that the robustness comes from the input", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 719, + 460, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 460, + 733 + ], + "score": 1.0, + "content": "discretization, and is not merely a byproduct of having a slightly higher-capacity model.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5, + "bbox_fs": [ + 104, + 665, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 195, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 197, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 197, + 97 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 161 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 504, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 504, + 117 + ], + "score": 1.0, + "content": "Our findings convincingly demonstrate that the use of thermometer encodings, in combination with", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "adversarial training, can reduce the vulnerability of neural network models to adversarial attacks.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 128, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 505, + 140 + ], + "score": 1.0, + "content": "Our analysis reveals that the resulting networks are significantly less linear with respect to their", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 137, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 152 + ], + "score": 1.0, + "content": "inputs, supporting the hypothesis of Goodfellow et al. (2014) that many adversarial examples are", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 150, + 351, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 351, + 162 + ], + "score": 1.0, + "content": "caused by over-generalization in networks that are too linear.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 107, + 177, + 175, + 189 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 176, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 176, + 191 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 195, + 506, + 240 + ], + "lines": [ + { + "bbox": [ + 105, + 194, + 505, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 208 + ], + "score": 1.0, + "content": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 207, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 115, + 207, + 506, + 219 + ], + "score": 1.0, + "content": "gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 115, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387–", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 200, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 200, + 240 + ], + "score": 1.0, + "content": "402. Springer, 2013.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 504, + 280 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 115, + 258, + 505, + 270 + ], + "score": 1.0, + "content": "networks: Improving robustness to adversarial examples. In International Conference on Machine", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 268, + 238, + 281 + ], + "spans": [ + { + "bbox": [ + 115, + 268, + 238, + 281 + ], + "score": 1.0, + "content": "Learning, pp. 854–863, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 286, + 504, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "score": 1.0, + "content": "Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 298, + 317, + 310 + ], + "spans": [ + { + "bbox": [ + 115, + 298, + 317, + 310 + ], + "score": 1.0, + "content": "networks. arXiv preprint arXiv:1302.4389, 2013.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 315, + 504, + 339 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 329 + ], + "score": 1.0, + "content": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 327, + 317, + 339 + ], + "spans": [ + { + "bbox": [ + 115, + 327, + 317, + 339 + ], + "score": 1.0, + "content": "examples. arXiv preprint arXiv:1412.6572, 2014.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 105, + 344, + 504, + 368 + ], + "lines": [ + { + "bbox": [ + 106, + 344, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 505, + 357 + ], + "score": 1.0, + "content": "Jun Han and Claudio Moraga. The influence of the sigmoid function parameters on the speed of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 356, + 495, + 369 + ], + "spans": [ + { + "bbox": [ + 116, + 356, + 495, + 369 + ], + "score": 1.0, + "content": "backpropagation learning. From Natural to Artificial Neural Computation, pp. 195–201, 1995.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 373, + 504, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 388 + ], + "score": 1.0, + "content": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 384, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 384, + 505, + 399 + ], + "score": 1.0, + "content": "nition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 394, + 182, + 408 + ], + "spans": [ + { + "bbox": [ + 115, + 394, + 182, + 408 + ], + "score": 1.0, + "content": "770–778, 2016.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 503, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 428 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 425, + 191, + 437 + ], + "spans": [ + { + "bbox": [ + 116, + 425, + 191, + 437 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 443, + 504, + 466 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 456 + ], + "score": 1.0, + "content": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 453, + 490, + 467 + ], + "spans": [ + { + "bbox": [ + 115, + 453, + 490, + 467 + ], + "score": 1.0, + "content": "stochastic depth. In European Conference on Computer Vision, pp. 646–661. Springer, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 106, + 472, + 504, + 495 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 484, + 254, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 484, + 254, + 496 + ], + "score": 1.0, + "content": "preprint arXiv:1611.01144, 2016.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 504, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "score": 1.0, + "content": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 513, + 254, + 525 + ], + "spans": [ + { + "bbox": [ + 114, + 513, + 254, + 525 + ], + "score": 1.0, + "content": "preprint arXiv:1611.01236, 2016.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 530, + 504, + 554 + ], + "lines": [ + { + "bbox": [ + 104, + 529, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 104, + 529, + 505, + 544 + ], + "score": 1.0, + "content": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 541, + 144, + 554 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 144, + 554 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 108, + 559, + 504, + 593 + ], + "lines": [ + { + "bbox": [ + 106, + 559, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 505, + 573 + ], + "score": 1.0, + "content": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial exam-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 570, + 504, + 583 + ], + "spans": [ + { + "bbox": [ + 116, + 570, + 504, + 583 + ], + "score": 1.0, + "content": "ples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 582, + 181, + 593 + ], + "spans": [ + { + "bbox": [ + 116, + 582, + 181, + 593 + ], + "score": 1.0, + "content": "1611.02770.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 600, + 502, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 599, + 504, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 504, + 613 + ], + "score": 1.0, + "content": "Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 611, + 440, + 624 + ], + "spans": [ + { + "bbox": [ + 116, + 611, + 440, + 624 + ], + "score": 1.0, + "content": "relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 629, + 503, + 663 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 116, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 650, + 143, + 663 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 143, + 663 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 106, + 669, + 503, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 669, + 504, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 504, + 682 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 279, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 279, + 693 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1601.06759, 2016.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 504, + 711 + ], + "score": 1.0, + "content": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Swami. Practical black-box attacks against deep learning systems using adversarial examples.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 721, + 279, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 279, + 732 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1602.02697, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 195, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 197, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 197, + 97 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 106, + 505, + 161 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 504, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 504, + 117 + ], + "score": 1.0, + "content": "Our findings convincingly demonstrate that the use of thermometer encodings, in combination with", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "adversarial training, can reduce the vulnerability of neural network models to adversarial attacks.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 128, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 505, + 140 + ], + "score": 1.0, + "content": "Our analysis reveals that the resulting networks are significantly less linear with respect to their", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 137, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 152 + ], + "score": 1.0, + "content": "inputs, supporting the hypothesis of Goodfellow et al. (2014) that many adversarial examples are", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 150, + 351, + 162 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 351, + 162 + ], + "score": 1.0, + "content": "caused by over-generalization in networks that are too linear.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 106, + 506, + 162 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 177, + 175, + 189 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 176, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 176, + 191 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 195, + 506, + 240 + ], + "lines": [ + { + "bbox": [ + 105, + 194, + 505, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 505, + 208 + ], + "score": 1.0, + "content": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 207, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 115, + 207, + 506, + 219 + ], + "score": 1.0, + "content": "gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 115, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387–", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 228, + 200, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 228, + 200, + 240 + ], + "score": 1.0, + "content": "402. Springer, 2013.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 194, + 506, + 240 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 504, + 280 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 115, + 258, + 505, + 270 + ], + "score": 1.0, + "content": "networks: Improving robustness to adversarial examples. In International Conference on Machine", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 268, + 238, + 281 + ], + "spans": [ + { + "bbox": [ + 115, + 268, + 238, + 281 + ], + "score": 1.0, + "content": "Learning, pp. 854–863, 2017.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 246, + 505, + 281 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 286, + 504, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "score": 1.0, + "content": "Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 298, + 317, + 310 + ], + "spans": [ + { + "bbox": [ + 115, + 298, + 317, + 310 + ], + "score": 1.0, + "content": "networks. arXiv preprint arXiv:1302.4389, 2013.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 285, + 505, + 310 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 315, + 504, + 339 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 329 + ], + "score": 1.0, + "content": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 327, + 317, + 339 + ], + "spans": [ + { + "bbox": [ + 115, + 327, + 317, + 339 + ], + "score": 1.0, + "content": "examples. arXiv preprint arXiv:1412.6572, 2014.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 315, + 505, + 339 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 344, + 504, + 368 + ], + "lines": [ + { + "bbox": [ + 106, + 344, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 505, + 357 + ], + "score": 1.0, + "content": "Jun Han and Claudio Moraga. The influence of the sigmoid function parameters on the speed of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 356, + 495, + 369 + ], + "spans": [ + { + "bbox": [ + 116, + 356, + 495, + 369 + ], + "score": 1.0, + "content": "backpropagation learning. From Natural to Artificial Neural Computation, pp. 195–201, 1995.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 106, + 344, + 505, + 369 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 373, + 504, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 388 + ], + "score": 1.0, + "content": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 384, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 115, + 384, + 505, + 399 + ], + "score": 1.0, + "content": "nition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 394, + 182, + 408 + ], + "spans": [ + { + "bbox": [ + 115, + 394, + 182, + 408 + ], + "score": 1.0, + "content": "770–778, 2016.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 372, + 505, + 408 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 503, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 412, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 505, + 428 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 425, + 191, + 437 + ], + "spans": [ + { + "bbox": [ + 116, + 425, + 191, + 437 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 412, + 505, + 437 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 443, + 504, + 466 + ], + "lines": [ + { + "bbox": [ + 106, + 443, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 456 + ], + "score": 1.0, + "content": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 453, + 490, + 467 + ], + "spans": [ + { + "bbox": [ + 115, + 453, + 490, + 467 + ], + "score": 1.0, + "content": "stochastic depth. In European Conference on Computer Vision, pp. 646–661. Springer, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 443, + 505, + 467 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 472, + 504, + 495 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 484, + 254, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 484, + 254, + 496 + ], + "score": 1.0, + "content": "preprint arXiv:1611.01144, 2016.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 471, + 505, + 496 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 504, + 524 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 515 + ], + "score": 1.0, + "content": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 513, + 254, + 525 + ], + "spans": [ + { + "bbox": [ + 114, + 513, + 254, + 525 + ], + "score": 1.0, + "content": "preprint arXiv:1611.01236, 2016.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 500, + 505, + 525 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 530, + 504, + 554 + ], + "lines": [ + { + "bbox": [ + 104, + 529, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 104, + 529, + 505, + 544 + ], + "score": 1.0, + "content": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 541, + 144, + 554 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 144, + 554 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 104, + 529, + 505, + 554 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 559, + 504, + 593 + ], + "lines": [ + { + "bbox": [ + 106, + 559, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 505, + 573 + ], + "score": 1.0, + "content": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial exam-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 570, + 504, + 583 + ], + "spans": [ + { + "bbox": [ + 116, + 570, + 504, + 583 + ], + "score": 1.0, + "content": "ples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 582, + 181, + 593 + ], + "spans": [ + { + "bbox": [ + 116, + 582, + 181, + 593 + ], + "score": 1.0, + "content": "1611.02770.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 106, + 559, + 505, + 593 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 600, + 502, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 599, + 504, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 504, + 613 + ], + "score": 1.0, + "content": "Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 611, + 440, + 624 + ], + "spans": [ + { + "bbox": [ + 116, + 611, + 440, + 624 + ], + "score": 1.0, + "content": "relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 599, + 504, + 624 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 629, + 503, + 663 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 642 + ], + "score": 1.0, + "content": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 116, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 116, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 650, + 143, + 663 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 143, + 663 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 628, + 505, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 669, + 503, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 669, + 504, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 504, + 682 + ], + "score": 1.0, + "content": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 680, + 279, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 680, + 279, + 693 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1601.06759, 2016.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 106, + 669, + 504, + 693 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 504, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 504, + 711 + ], + "score": 1.0, + "content": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Swami. Practical black-box attacks against deep learning systems using adversarial examples.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 721, + 279, + 732 + ], + "spans": [ + { + "bbox": [ + 116, + 721, + 279, + 732 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1602.02697, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 699, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 108, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 108, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfel-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "low, and Rob Fergus. Intriguing properties of neural networks. ICLR, abs/1312.6199, 2014. URL", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 301, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 301, + 117 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1312.6199.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 124, + 504, + 147 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 138 + ], + "score": 1.0, + "content": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 136, + 349, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 136, + 349, + 147 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1704.01155, 2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 155, + 505, + 178 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 155, + 298, + 168 + ], + "score": 1.0, + "content": "Sergey Zagoruyko and Nikos Komodakis.", + "type": "text" + }, + { + "bbox": [ + 312, + 154, + 428, + 169 + ], + "score": 1.0, + "content": "Wide residual networks.", + "type": "text" + }, + { + "bbox": [ + 438, + 155, + 505, + 169 + ], + "score": 1.0, + "content": "arXiv preprint", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 167, + 220, + 178 + ], + "spans": [ + { + "bbox": [ + 115, + 167, + 220, + 178 + ], + "score": 1.0, + "content": "arXiv:1605.07146, 2016.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "title", + "bbox": [ + 108, + 201, + 233, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 201, + 235, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 235, + 216 + ], + "score": 1.0, + "content": "A HYPERPARAMETERS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "In this section, we describe the hyperparameters used in our experiments. For CIFAR-10 and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 237, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 506, + 250 + ], + "score": 1.0, + "content": "CIFAR-100 we follow the standard data augmenting scheme as in (Lin et al., 2013; He et al., 2016;", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "score": 1.0, + "content": "Huang et al., 2016; Zagoruyko & Komodakis, 2016): each training image is zero-padded with 4", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 311, + 272 + ], + "score": 1.0, + "content": "pixels on each side and randomly cropped to a new", + "type": "text" + }, + { + "bbox": [ + 311, + 260, + 343, + 270 + ], + "score": 0.9, + "content": "3 2 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "image. The resulting image is randomly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 270, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 506, + 284 + ], + "score": 1.0, + "content": "flipped with probability 0.5, it’s brightness is adjusted with a delta chosen uniformly at random", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 104, + 281, + 166, + 294 + ], + "score": 1.0, + "content": "in the interval", + "type": "text" + }, + { + "bbox": [ + 166, + 282, + 205, + 294 + ], + "score": 0.83, + "content": "[ - 6 3 , 6 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "and it’s contrast is adjusted using a random contrast factor in the interval", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 292, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 429, + 306 + ], + "score": 1.0, + "content": "[0.2, 1.8]. For MNIST we use the Adam optimizer with a fixed learning rate of", + "type": "text" + }, + { + "bbox": [ + 429, + 293, + 453, + 303 + ], + "score": 0.3, + "content": "1 \\mathrm { e } { - 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 292, + 505, + 306 + ], + "score": 1.0, + "content": "as in Madry", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 304, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 505, + 315 + ], + "score": 1.0, + "content": "et al. (2017). For CIFAR-10 and CIFAR-100 we use the Momentum optimizer with momentum 0.9,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 117, + 326 + ], + "score": 0.86, + "content": "\\ell _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 314, + 185, + 327 + ], + "score": 1.0, + "content": "weight decay of", + "type": "text" + }, + { + "bbox": [ + 185, + 315, + 235, + 325 + ], + "score": 0.87, + "content": "\\lambda = 0 . 0 0 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "and an initial learning rate of 0.1 which is annealed by a factor of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "score": 1.0, + "content": "0.2 after epochs 60, 120 and 160 respectively as in Zagoruyko & Komodakis (2016). For SVHN", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 330, + 348 + ], + "score": 1.0, + "content": "we use the same optimizer with initial learning rate of", + "type": "text" + }, + { + "bbox": [ + 331, + 337, + 354, + 347 + ], + "score": 0.3, + "content": "\\mathrm { 1 e { - } 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "which is annealed by a factor of 0.1", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "after epochs 80 and 120 respectively. We also use a dropout of 0.3 for CIFAR-10, CIFAR-100 and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 358, + 139, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 139, + 370 + ], + "score": 1.0, + "content": "SVHN.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 386, + 204, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 205, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 205, + 402 + ], + "score": 1.0, + "content": "B PSEUDO-CODE", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 108, + 412, + 503, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "score": 1.0, + "content": "The DGA attack is described in Algorithm 2 and the LS-PGA attack is described in Algorithm 3.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 423, + 492, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 492, + 435 + ], + "score": 1.0, + "content": "Both these algorithms make use of a getM ask() sub-routine which is described in Algorithm 1.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "table", + "bbox": [ + 99, + 450, + 504, + 559 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 99, + 450, + 504, + 559 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 99, + 450, + 504, + 559 + ], + "spans": [ + { + "bbox": [ + 99, + 450, + 504, + 559 + ], + "score": 0.191, + "html": "
Input: Image x, parameter ε
Output: ε-discretized mask around x
2mask ← (0)nxk
3low ← max{0,x - ε}
4high ← min{1,𝑥 +ε}
5for α←O to1by do
6mask ← mask+ fonehot (α * low + (1- α) * high) end
7return mask
", + "type": "table", + "image_path": "9376c7f2852ce1eaf9c3b18c9853655bc772a48fc60e32f3a1bebfc9fa57523b.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 99, + 450, + 504, + 486.3333333333333 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 99, + 486.3333333333333, + 504, + 522.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 99, + 522.6666666666666, + 504, + 559.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 152, + 558, + 443, + 569 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 556, + 444, + 572 + ], + "spans": [ + { + "bbox": [ + 151, + 556, + 315, + 572 + ], + "score": 1.0, + "content": "Algorithm 1: Sub-routine for getting an", + "type": "text" + }, + { + "bbox": [ + 316, + 561, + 321, + 568 + ], + "score": 0.75, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 556, + 444, + 572 + ], + "score": 1.0, + "content": "-discretized mask of an image.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + } + ], + "index": 26.0 + }, + { + "type": "title", + "bbox": [ + 107, + 601, + 333, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 600, + 334, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 334, + 616 + ], + "score": 1.0, + "content": "C ADDITIONAL EXPERIMENTS ON MNIST", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 626, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "In this section we list the additional experiments we performed using discretized models on MNIST.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 343, + 650 + ], + "score": 1.0, + "content": "The main hyperparameters of Algorithm 3 are the step size", + "type": "text" + }, + { + "bbox": [ + 343, + 639, + 349, + 649 + ], + "score": 0.83, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "used to perform the projected gradient", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 244, + 662 + ], + "score": 1.0, + "content": "ascent, and the annealing rate of", + "type": "text" + }, + { + "bbox": [ + 244, + 649, + 250, + 659 + ], + "score": 0.69, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 649, + 506, + 662 + ], + "score": 1.0, + "content": ". We found that the choice of these hyperparameters was not", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 452, + 673 + ], + "score": 1.0, + "content": "critical to the robustness of the model. In particular, we performed experiments with", + "type": "text" + }, + { + "bbox": [ + 452, + 660, + 487, + 672 + ], + "score": 0.92, + "content": "\\xi = 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 671, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 149, + 682 + ], + "score": 0.9, + "content": "\\xi = 0 . 0 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 671, + 506, + 683 + ], + "score": 1.0, + "content": ", and both achieved similar accuracies as in Table 2 and Table 3. Additionally, we found", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 681, + 493, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 218, + 694 + ], + "score": 1.0, + "content": "that without annealing, i.e.,", + "type": "text" + }, + { + "bbox": [ + 218, + 682, + 250, + 692 + ], + "score": 0.89, + "content": "\\delta = 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 681, + 457, + 694 + ], + "score": 1.0, + "content": ", the performance was only slightly worse than with", + "type": "text" + }, + { + "bbox": [ + 458, + 682, + 489, + 692 + ], + "score": 0.9, + "content": "\\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 681, + 493, + 694 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "We also experimented with discretizing by using percentile information per color channel instead of", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "using uniformly distributed buckets. This did not result in any significant changes in robustness or", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 720, + 239, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 239, + 732 + ], + "score": 1.0, + "content": "accuracy for the MNIST dataset.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 108, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 108, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfel-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "low, and Rob Fergus. Intriguing properties of neural networks. ICLR, abs/1312.6199, 2014. URL", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 301, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 301, + 117 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1312.6199.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 108, + 82, + 506, + 117 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 124, + 504, + 147 + ], + "lines": [ + { + "bbox": [ + 106, + 123, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 138 + ], + "score": 1.0, + "content": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 136, + 349, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 136, + 349, + 147 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1704.01155, 2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 106, + 123, + 505, + 147 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 155, + 505, + 178 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 155, + 298, + 168 + ], + "score": 1.0, + "content": "Sergey Zagoruyko and Nikos Komodakis.", + "type": "text" + }, + { + "bbox": [ + 312, + 154, + 428, + 169 + ], + "score": 1.0, + "content": "Wide residual networks.", + "type": "text" + }, + { + "bbox": [ + 438, + 155, + 505, + 169 + ], + "score": 1.0, + "content": "arXiv preprint", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 167, + 220, + 178 + ], + "spans": [ + { + "bbox": [ + 115, + 167, + 220, + 178 + ], + "score": 1.0, + "content": "arXiv:1605.07146, 2016.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 154, + 505, + 178 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 201, + 233, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 201, + 235, + 216 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 235, + 216 + ], + "score": 1.0, + "content": "A HYPERPARAMETERS", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 505, + 369 + ], + "lines": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 226, + 506, + 239 + ], + "score": 1.0, + "content": "In this section, we describe the hyperparameters used in our experiments. For CIFAR-10 and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 237, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 506, + 250 + ], + "score": 1.0, + "content": "CIFAR-100 we follow the standard data augmenting scheme as in (Lin et al., 2013; He et al., 2016;", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "score": 1.0, + "content": "Huang et al., 2016; Zagoruyko & Komodakis, 2016): each training image is zero-padded with 4", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 311, + 272 + ], + "score": 1.0, + "content": "pixels on each side and randomly cropped to a new", + "type": "text" + }, + { + "bbox": [ + 311, + 260, + 343, + 270 + ], + "score": 0.9, + "content": "3 2 \\times 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "image. The resulting image is randomly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 270, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 506, + 284 + ], + "score": 1.0, + "content": "flipped with probability 0.5, it’s brightness is adjusted with a delta chosen uniformly at random", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 281, + 505, + 294 + ], + "spans": [ + { + "bbox": [ + 104, + 281, + 166, + 294 + ], + "score": 1.0, + "content": "in the interval", + "type": "text" + }, + { + "bbox": [ + 166, + 282, + 205, + 294 + ], + "score": 0.83, + "content": "[ - 6 3 , 6 3 )", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 281, + 505, + 294 + ], + "score": 1.0, + "content": "and it’s contrast is adjusted using a random contrast factor in the interval", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 292, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 292, + 429, + 306 + ], + "score": 1.0, + "content": "[0.2, 1.8]. For MNIST we use the Adam optimizer with a fixed learning rate of", + "type": "text" + }, + { + "bbox": [ + 429, + 293, + 453, + 303 + ], + "score": 0.3, + "content": "1 \\mathrm { e } { - 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 292, + 505, + 306 + ], + "score": 1.0, + "content": "as in Madry", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 304, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 505, + 315 + ], + "score": 1.0, + "content": "et al. (2017). For CIFAR-10 and CIFAR-100 we use the Momentum optimizer with momentum 0.9,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 117, + 326 + ], + "score": 0.86, + "content": "\\ell _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 314, + 185, + 327 + ], + "score": 1.0, + "content": "weight decay of", + "type": "text" + }, + { + "bbox": [ + 185, + 315, + 235, + 325 + ], + "score": 0.87, + "content": "\\lambda = 0 . 0 0 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "and an initial learning rate of 0.1 which is annealed by a factor of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 338 + ], + "score": 1.0, + "content": "0.2 after epochs 60, 120 and 160 respectively as in Zagoruyko & Komodakis (2016). For SVHN", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 330, + 348 + ], + "score": 1.0, + "content": "we use the same optimizer with initial learning rate of", + "type": "text" + }, + { + "bbox": [ + 331, + 337, + 354, + 347 + ], + "score": 0.3, + "content": "\\mathrm { 1 e { - } 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "which is annealed by a factor of 0.1", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "after epochs 80 and 120 respectively. We also use a dropout of 0.3 for CIFAR-10, CIFAR-100 and", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 358, + 139, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 139, + 370 + ], + "score": 1.0, + "content": "SVHN.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 14, + "bbox_fs": [ + 104, + 226, + 506, + 370 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 386, + 204, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 205, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 205, + 402 + ], + "score": 1.0, + "content": "B PSEUDO-CODE", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "list", + "bbox": [ + 108, + 412, + 503, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "score": 1.0, + "content": "The DGA attack is described in Algorithm 2 and the LS-PGA attack is described in Algorithm 3.", + "type": "text" + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 423, + 492, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 492, + 435 + ], + "score": 1.0, + "content": "Both these algorithms make use of a getM ask() sub-routine which is described in Algorithm 1.", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 412, + 505, + 435 + ] + }, + { + "type": "table", + "bbox": [ + 99, + 450, + 504, + 559 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 99, + 450, + 504, + 559 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 99, + 450, + 504, + 559 + ], + "spans": [ + { + "bbox": [ + 99, + 450, + 504, + 559 + ], + "score": 0.191, + "html": "
Input: Image x, parameter ε
Output: ε-discretized mask around x
2mask ← (0)nxk
3low ← max{0,x - ε}
4high ← min{1,𝑥 +ε}
5for α←O to1by do
6mask ← mask+ fonehot (α * low + (1- α) * high) end
7return mask
", + "type": "table", + "image_path": "9376c7f2852ce1eaf9c3b18c9853655bc772a48fc60e32f3a1bebfc9fa57523b.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 99, + 450, + 504, + 486.3333333333333 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 99, + 486.3333333333333, + 504, + 522.6666666666666 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 99, + 522.6666666666666, + 504, + 559.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 152, + 558, + 443, + 569 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 151, + 556, + 444, + 572 + ], + "spans": [ + { + "bbox": [ + 151, + 556, + 315, + 572 + ], + "score": 1.0, + "content": "Algorithm 1: Sub-routine for getting an", + "type": "text" + }, + { + "bbox": [ + 316, + 561, + 321, + 568 + ], + "score": 0.75, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 556, + 444, + 572 + ], + "score": 1.0, + "content": "-discretized mask of an image.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + } + ], + "index": 26.0 + }, + { + "type": "title", + "bbox": [ + 107, + 601, + 333, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 600, + 334, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 334, + 616 + ], + "score": 1.0, + "content": "C ADDITIONAL EXPERIMENTS ON MNIST", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 626, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "In this section we list the additional experiments we performed using discretized models on MNIST.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 343, + 650 + ], + "score": 1.0, + "content": "The main hyperparameters of Algorithm 3 are the step size", + "type": "text" + }, + { + "bbox": [ + 343, + 639, + 349, + 649 + ], + "score": 0.83, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "used to perform the projected gradient", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 244, + 662 + ], + "score": 1.0, + "content": "ascent, and the annealing rate of", + "type": "text" + }, + { + "bbox": [ + 244, + 649, + 250, + 659 + ], + "score": 0.69, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 649, + 506, + 662 + ], + "score": 1.0, + "content": ". We found that the choice of these hyperparameters was not", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 660, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 452, + 673 + ], + "score": 1.0, + "content": "critical to the robustness of the model. In particular, we performed experiments with", + "type": "text" + }, + { + "bbox": [ + 452, + 660, + 487, + 672 + ], + "score": 0.92, + "content": "\\xi = 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 660, + 506, + 673 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 671, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 149, + 682 + ], + "score": 0.9, + "content": "\\xi = 0 . 0 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 671, + 506, + 683 + ], + "score": 1.0, + "content": ", and both achieved similar accuracies as in Table 2 and Table 3. Additionally, we found", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 681, + 493, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 218, + 694 + ], + "score": 1.0, + "content": "that without annealing, i.e.,", + "type": "text" + }, + { + "bbox": [ + 218, + 682, + 250, + 692 + ], + "score": 0.89, + "content": "\\delta = 1 . 0", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 681, + 457, + 694 + ], + "score": 1.0, + "content": ", the performance was only slightly worse than with", + "type": "text" + }, + { + "bbox": [ + 458, + 682, + 489, + 692 + ], + "score": 0.9, + "content": "\\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 681, + 493, + 694 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 626, + 506, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "We also experimented with discretizing by using percentile information per color channel instead of", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "using uniformly distributed buckets. This did not result in any significant changes in robustness or", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 720, + 239, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 239, + 732 + ], + "score": 1.0, + "content": "accuracy for the MNIST dataset.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 698, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 97, + 85, + 501, + 283 + ], + "lines": [ + { + "bbox": [ + 106, + 84, + 489, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 164, + 100 + ], + "score": 1.0, + "content": "Input: Image", + "type": "text" + }, + { + "bbox": [ + 164, + 89, + 171, + 97 + ], + "score": 0.71, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 84, + 196, + 100 + ], + "score": 1.0, + "content": ", label", + "type": "text" + }, + { + "bbox": [ + 196, + 89, + 203, + 98 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 84, + 298, + 100 + ], + "score": 1.0, + "content": ", discretization function", + "type": "text" + }, + { + "bbox": [ + 298, + 87, + 305, + 98 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 84, + 326, + 100 + ], + "score": 1.0, + "content": ", loss", + "type": "text" + }, + { + "bbox": [ + 327, + 86, + 380, + 99 + ], + "score": 0.76, + "content": "\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 84, + 483, + 100 + ], + "score": 1.0, + "content": ", l attack steps, parameter", + "type": "text" + }, + { + "bbox": [ + 483, + 89, + 489, + 96 + ], + "score": 0.49, + "content": "\\varepsilon", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 96, + 285, + 109 + ], + "spans": [ + { + "bbox": [ + 106, + 96, + 275, + 109 + ], + "score": 1.0, + "content": "Output: Adversarial input to the network", + "type": "text" + }, + { + "bbox": [ + 276, + 97, + 285, + 107 + ], + "score": 0.82, + "content": "z ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 98, + 108, + 166, + 121 + ], + "spans": [ + { + "bbox": [ + 98, + 108, + 106, + 121 + ], + "score": 1.0, + "content": "1", + "type": "text" + }, + { + "bbox": [ + 106, + 108, + 166, + 119 + ], + "score": 0.5, + "content": "\\eta U ( - \\varepsilon , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 119, + 169, + 131 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 169, + 131 + ], + "score": 0.58, + "content": " { \\vert z _ { 0 } \\gets f ( x + \\dot { \\eta } ) }", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 99, + 130, + 208, + 143 + ], + "spans": [ + { + "bbox": [ + 99, + 130, + 106, + 143 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 106, + 131, + 208, + 142 + ], + "score": 0.59, + "content": "\\mathrm { m a s k } g e t M a s k ( x , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 141, + 178, + 153 + ], + "spans": [ + { + "bbox": [ + 104, + 141, + 121, + 153 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 142, + 147, + 151 + ], + "score": 0.81, + "content": "t \\gets 1", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 141, + 158, + 153 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 159, + 142, + 163, + 151 + ], + "score": 0.39, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 141, + 178, + 153 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 122, + 152, + 490, + 164 + ], + "spans": [ + { + "bbox": [ + 122, + 153, + 135, + 163 + ], + "score": 0.48, + "content": "/ \\star", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 152, + 232, + 164 + ], + "score": 1.0, + "content": "Loop invariant:", + "type": "text" + }, + { + "bbox": [ + 241, + 152, + 252, + 164 + ], + "score": 0.85, + "content": "z _ { i } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 152, + 448, + 164 + ], + "score": 1.0, + "content": "is discretized for every pixel i", + "type": "text" + }, + { + "bbox": [ + 475, + 152, + 490, + 164 + ], + "score": 1.0, + "content": "*/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 100, + 164, + 236, + 177 + ], + "spans": [ + { + "bbox": [ + 100, + 169, + 103, + 174 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 121, + 164, + 236, + 177 + ], + "score": 0.74, + "content": "\\mathrm { g r a d } \\nabla _ { z ^ { t - 1 } } \\mathbb { L } ( \\pmb \\theta , z ^ { t - 1 } , y )", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 100, + 176, + 203, + 187 + ], + "spans": [ + { + "bbox": [ + 100, + 180, + 103, + 185 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 121, + 176, + 130, + 187 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 131, + 176, + 138, + 187 + ], + "score": 0.75, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 176, + 203, + 187 + ], + "score": 1.0, + "content": "is one-hot then", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 100, + 186, + 263, + 200 + ], + "spans": [ + { + "bbox": [ + 100, + 192, + 104, + 196 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 134, + 186, + 263, + 200 + ], + "score": 0.41, + "content": "\\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\chi ( l ) ) ^ { \\top } \\mathrm { g r a d }", + "type": "inline_equation", + "image_path": "9e4c620bc82aece5dabfd75a02d409ea849fbaa82fc239424e7804fa6812d1b4.jpg" + } + ], + "index": 9 + }, + { + "bbox": [ + 99, + 196, + 142, + 211 + ], + "spans": [ + { + "bbox": [ + 99, + 202, + 104, + 209 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 120, + 196, + 142, + 211 + ], + "score": 1.0, + "content": "else", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 99, + 208, + 263, + 222 + ], + "spans": [ + { + "bbox": [ + 99, + 214, + 105, + 220 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 127, + 208, + 263, + 222 + ], + "score": 0.36, + "content": "\\vert \\quad \\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\tau ( l ) ) ^ { \\top } \\mathrm { g r a d }", + "type": "inline_equation", + "image_path": "bc1f9cf8ca940932dbc08ea9eaf962786f780852f74cbe5979bc9601ecaebdc8.jpg" + } + ], + "index": 11 + }, + { + "bbox": [ + 96, + 221, + 140, + 232 + ], + "spans": [ + { + "bbox": [ + 96, + 224, + 104, + 231 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 121, + 221, + 140, + 232 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 96, + 232, + 295, + 244 + ], + "spans": [ + { + "bbox": [ + 96, + 235, + 104, + 243 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 119, + 232, + 295, + 244 + ], + "score": 0.33, + "content": "\\mathrm { h a r m } \\gets \\mathrm { h a r m } * \\mathrm { m a s k } - ( 1 - \\mathrm { m a s k } ) * \\infty", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 96, + 242, + 227, + 258 + ], + "spans": [ + { + "bbox": [ + 96, + 246, + 105, + 256 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 120, + 242, + 227, + 258 + ], + "score": 1.0, + "content": "zt ← f (arg max(harm))", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 95, + 256, + 126, + 268 + ], + "spans": [ + { + "bbox": [ + 95, + 258, + 106, + 267 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 105, + 256, + 126, + 268 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 93, + 268, + 171, + 281 + ], + "spans": [ + { + "bbox": [ + 93, + 268, + 171, + 281 + ], + "score": 1.0, + "content": "14 return z0 ← zl", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 96, + 312, + 503, + 551 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 489, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 164, + 326 + ], + "score": 1.0, + "content": "Input: Image", + "type": "text" + }, + { + "bbox": [ + 164, + 316, + 171, + 323 + ], + "score": 0.64, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 311, + 196, + 326 + ], + "score": 1.0, + "content": ", label", + "type": "text" + }, + { + "bbox": [ + 197, + 316, + 203, + 325 + ], + "score": 0.73, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 311, + 298, + 326 + ], + "score": 1.0, + "content": ", discretization function", + "type": "text" + }, + { + "bbox": [ + 299, + 314, + 306, + 325 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 311, + 327, + 326 + ], + "score": 1.0, + "content": ", loss", + "type": "text" + }, + { + "bbox": [ + 327, + 313, + 381, + 325 + ], + "score": 0.89, + "content": "\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 311, + 385, + 326 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 385, + 314, + 390, + 324 + ], + "score": 0.43, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 311, + 489, + 326 + ], + "score": 1.0, + "content": "attack steps, parameters", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 133, + 324, + 155, + 335 + ], + "spans": [ + { + "bbox": [ + 133, + 324, + 155, + 335 + ], + "score": 1.0, + "content": "ε, δ", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 334, + 285, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 275, + 348 + ], + "score": 1.0, + "content": "Output: Adversarial input to the network", + "type": "text" + }, + { + "bbox": [ + 276, + 335, + 285, + 345 + ], + "score": 0.81, + "content": "z ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 346, + 208, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 208, + 357 + ], + "score": 0.66, + "content": "\\mathrm { m a s k } g e t M a s k ( x , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 103, + 358, + 302, + 372 + ], + "spans": [ + { + "bbox": [ + 103, + 358, + 302, + 372 + ], + "score": 0.37, + "content": "u ^ { 0 } \\gets \\left( \\mathcal { N } ( \\mathbf { 0 } ^ { k } ; \\mathbf { 1 } ^ { k } ) \\right) ^ { n } * \\mathrm { m a s k - } \\left( 1 - \\mathrm { m a s k } \\right) * \\infty", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 99, + 371, + 139, + 383 + ], + "spans": [ + { + "bbox": [ + 99, + 375, + 105, + 380 + ], + "score": 0.998, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 104, + 371, + 139, + 383 + ], + "score": 1.0, + "content": "T ← 1", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 382, + 187, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 382, + 115, + 394 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 115, + 383, + 122, + 394 + ], + "score": 0.66, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 382, + 187, + 394 + ], + "score": 1.0, + "content": "is one-hot then", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 100, + 391, + 152, + 406 + ], + "spans": [ + { + "bbox": [ + 100, + 398, + 103, + 402 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 113, + 391, + 152, + 406 + ], + "score": 1.0, + "content": "F ← I", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 99, + 403, + 128, + 416 + ], + "spans": [ + { + "bbox": [ + 99, + 408, + 104, + 414 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 103, + 403, + 128, + 416 + ], + "score": 1.0, + "content": "else", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 99, + 413, + 155, + 428 + ], + "spans": [ + { + "bbox": [ + 99, + 419, + 104, + 425 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 107, + 413, + 155, + 428 + ], + "score": 1.0, + "content": "F ← C", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 98, + 425, + 127, + 439 + ], + "spans": [ + { + "bbox": [ + 98, + 429, + 106, + 437 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 101, + 425, + 127, + 439 + ], + "score": 1.0, + "content": "8 end", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 101, + 435, + 185, + 460 + ], + "spans": [ + { + "bbox": [ + 101, + 435, + 185, + 460 + ], + "score": 1.0, + "content": "9 z 0 ← F \u0010 σ \u0010 u 0T \u0011\u0011", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 95, + 456, + 179, + 468 + ], + "spans": [ + { + "bbox": [ + 95, + 458, + 105, + 468 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 105, + 456, + 121, + 468 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 122, + 458, + 147, + 467 + ], + "score": 0.56, + "content": "t \\gets 1", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 456, + 158, + 468 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 159, + 459, + 163, + 467 + ], + "score": 0.36, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 456, + 179, + 468 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 96, + 466, + 237, + 481 + ], + "spans": [ + { + "bbox": [ + 96, + 471, + 104, + 479 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 120, + 466, + 237, + 481 + ], + "score": 1.0, + "content": "grad ← ∇ut−1 L(θ, zt−1, y)", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 95, + 478, + 238, + 494 + ], + "spans": [ + { + "bbox": [ + 95, + 483, + 105, + 493 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 120, + 478, + 238, + 494 + ], + "score": 1.0, + "content": "ut ← ut−1 + ξ · sign (grad)", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 95, + 491, + 198, + 513 + ], + "spans": [ + { + "bbox": [ + 95, + 498, + 105, + 509 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 118, + 491, + 198, + 513 + ], + "score": 1.0, + "content": "z t ← F \u0010 σ \u0010 u tT \u0011\u0011", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 95, + 510, + 168, + 523 + ], + "spans": [ + { + "bbox": [ + 95, + 514, + 105, + 523 + ], + "score": 1.0, + "content": "14", + "type": "text" + }, + { + "bbox": [ + 119, + 510, + 168, + 523 + ], + "score": 1.0, + "content": "T ← T · δ", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 94, + 523, + 126, + 536 + ], + "spans": [ + { + "bbox": [ + 94, + 525, + 106, + 536 + ], + "score": 1.0, + "content": "15", + "type": "text" + }, + { + "bbox": [ + 105, + 523, + 126, + 536 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 96, + 535, + 225, + 549 + ], + "spans": [ + { + "bbox": [ + 96, + 535, + 136, + 549 + ], + "score": 1.0, + "content": "16 return", + "type": "text" + }, + { + "bbox": [ + 136, + 536, + 225, + 549 + ], + "score": 0.79, + "content": "z ^ { \\prime } \\gets \\tau ( \\arg \\operatorname* { m a x } ( u _ { i } ^ { l } ) )", + "type": "inline_equation" + } + ], + "index": 36 + } + ], + "index": 27 + }, + { + "type": "table", + "bbox": [ + 185, + 574, + 426, + 660 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 203, + 284, + 393, + 295 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 202, + 282, + 394, + 298 + ], + "spans": [ + { + "bbox": [ + 202, + 282, + 394, + 298 + ], + "score": 1.0, + "content": "Algorithm 2: Discrete Gradient Ascent (DGA)", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "table_caption", + "bbox": [ + 168, + 552, + 428, + 563 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 167, + 550, + 429, + 565 + ], + "spans": [ + { + "bbox": [ + 167, + 550, + 429, + 565 + ], + "score": 1.0, + "content": "Algorithm 3: Logit-Space Projected Gradient Ascent (LS-PGA)", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "table_body", + "bbox": [ + 185, + 574, + 426, + 660 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 185, + 574, + 426, + 660 + ], + "spans": [ + { + "bbox": [ + 185, + 574, + 426, + 660 + ], + "score": 0.971, + "html": "
Modelm8White-boxBlack-box
One-hotOne-hotOne-hot1.00.0011.01.21.21.093.0893.5093.0298.3998.4298.21
ThermometerThermometerThermometer1.00.0011.01.21.21.093.7493.8893.7598.4598.2498.22
", + "type": "table", + "image_path": "a4a5f1d75cd1f4ec8cdc637a606aff4ff207bd741d258c9ac806a1099e0c742f.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 185, + 574, + 426, + 588.3333333333334 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 185, + 588.3333333333334, + 426, + 602.6666666666667 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 185, + 602.6666666666667, + 426, + 617.0000000000001 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 185, + 617.0000000000001, + 426, + 631.3333333333335 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 185, + 631.3333333333335, + 426, + 645.6666666666669 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 185, + 645.6666666666669, + 426, + 660.0000000000002 + ], + "spans": [], + "index": 43 + } + ] + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 108, + 668, + 505, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Table 6: Comparison of adversarial robustness to white-box attacks on MNIST using 16 levels and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 286, + 691 + ], + "score": 1.0, + "content": "with various choices of the hyperparameters", + "type": "text" + }, + { + "bbox": [ + 286, + 679, + 293, + 690 + ], + "score": 0.84, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 678, + 310, + 691 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 311, + 679, + 317, + 689 + ], + "score": 0.68, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "for Algorithm 3. The models are evaluated on", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 690, + 503, + 702 + ], + "spans": [ + { + "bbox": [ + 107, + 690, + 503, + 702 + ], + "score": 1.0, + "content": "white-box attacks and on black-box attacks using a vanilla, clean trained model; both use LS-PGA.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 97, + 85, + 501, + 283 + ], + "lines": [ + { + "bbox": [ + 106, + 84, + 489, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 164, + 100 + ], + "score": 1.0, + "content": "Input: Image", + "type": "text" + }, + { + "bbox": [ + 164, + 89, + 171, + 97 + ], + "score": 0.71, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 84, + 196, + 100 + ], + "score": 1.0, + "content": ", label", + "type": "text" + }, + { + "bbox": [ + 196, + 89, + 203, + 98 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 84, + 298, + 100 + ], + "score": 1.0, + "content": ", discretization function", + "type": "text" + }, + { + "bbox": [ + 298, + 87, + 305, + 98 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 84, + 326, + 100 + ], + "score": 1.0, + "content": ", loss", + "type": "text" + }, + { + "bbox": [ + 327, + 86, + 380, + 99 + ], + "score": 0.76, + "content": "\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 84, + 483, + 100 + ], + "score": 1.0, + "content": ", l attack steps, parameter", + "type": "text" + }, + { + "bbox": [ + 483, + 89, + 489, + 96 + ], + "score": 0.49, + "content": "\\varepsilon", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 96, + 285, + 109 + ], + "spans": [ + { + "bbox": [ + 106, + 96, + 275, + 109 + ], + "score": 1.0, + "content": "Output: Adversarial input to the network", + "type": "text" + }, + { + "bbox": [ + 276, + 97, + 285, + 107 + ], + "score": 0.82, + "content": "z ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 98, + 108, + 166, + 121 + ], + "spans": [ + { + "bbox": [ + 98, + 108, + 106, + 121 + ], + "score": 1.0, + "content": "1", + "type": "text" + }, + { + "bbox": [ + 106, + 108, + 166, + 119 + ], + "score": 0.5, + "content": "\\eta U ( - \\varepsilon , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 119, + 169, + 131 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 169, + 131 + ], + "score": 0.58, + "content": " { \\vert z _ { 0 } \\gets f ( x + \\dot { \\eta } ) }", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 99, + 130, + 208, + 143 + ], + "spans": [ + { + "bbox": [ + 99, + 130, + 106, + 143 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 106, + 131, + 208, + 142 + ], + "score": 0.59, + "content": "\\mathrm { m a s k } g e t M a s k ( x , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 141, + 178, + 153 + ], + "spans": [ + { + "bbox": [ + 104, + 141, + 121, + 153 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 121, + 142, + 147, + 151 + ], + "score": 0.81, + "content": "t \\gets 1", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 141, + 158, + 153 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 159, + 142, + 163, + 151 + ], + "score": 0.39, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 141, + 178, + 153 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 122, + 152, + 490, + 164 + ], + "spans": [ + { + "bbox": [ + 122, + 153, + 135, + 163 + ], + "score": 0.48, + "content": "/ \\star", + "type": "inline_equation" + }, + { + "bbox": [ + 135, + 152, + 232, + 164 + ], + "score": 1.0, + "content": "Loop invariant:", + "type": "text" + }, + { + "bbox": [ + 241, + 152, + 252, + 164 + ], + "score": 0.85, + "content": "z _ { i } ^ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 152, + 448, + 164 + ], + "score": 1.0, + "content": "is discretized for every pixel i", + "type": "text" + }, + { + "bbox": [ + 475, + 152, + 490, + 164 + ], + "score": 1.0, + "content": "*/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 100, + 164, + 236, + 177 + ], + "spans": [ + { + "bbox": [ + 100, + 169, + 103, + 174 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 121, + 164, + 236, + 177 + ], + "score": 0.74, + "content": "\\mathrm { g r a d } \\nabla _ { z ^ { t - 1 } } \\mathbb { L } ( \\pmb \\theta , z ^ { t - 1 } , y )", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 100, + 176, + 203, + 187 + ], + "spans": [ + { + "bbox": [ + 100, + 180, + 103, + 185 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 121, + 176, + 130, + 187 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 131, + 176, + 138, + 187 + ], + "score": 0.75, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 176, + 203, + 187 + ], + "score": 1.0, + "content": "is one-hot then", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 100, + 186, + 263, + 200 + ], + "spans": [ + { + "bbox": [ + 100, + 192, + 104, + 196 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 134, + 186, + 263, + 200 + ], + "score": 0.41, + "content": "\\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\chi ( l ) ) ^ { \\top } \\mathrm { g r a d }", + "type": "inline_equation", + "image_path": "9e4c620bc82aece5dabfd75a02d409ea849fbaa82fc239424e7804fa6812d1b4.jpg" + } + ], + "index": 9 + }, + { + "bbox": [ + 99, + 196, + 142, + 211 + ], + "spans": [ + { + "bbox": [ + 99, + 202, + 104, + 209 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 120, + 196, + 142, + 211 + ], + "score": 1.0, + "content": "else", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 99, + 208, + 263, + 222 + ], + "spans": [ + { + "bbox": [ + 99, + 214, + 105, + 220 + ], + "score": 1.0, + "content": "9", + "type": "text" + }, + { + "bbox": [ + 127, + 208, + 263, + 222 + ], + "score": 0.36, + "content": "\\vert \\quad \\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\tau ( l ) ) ^ { \\top } \\mathrm { g r a d }", + "type": "inline_equation", + "image_path": "bc1f9cf8ca940932dbc08ea9eaf962786f780852f74cbe5979bc9601ecaebdc8.jpg" + } + ], + "index": 11 + }, + { + "bbox": [ + 96, + 221, + 140, + 232 + ], + "spans": [ + { + "bbox": [ + 96, + 224, + 104, + 231 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 121, + 221, + 140, + 232 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 96, + 232, + 295, + 244 + ], + "spans": [ + { + "bbox": [ + 96, + 235, + 104, + 243 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 119, + 232, + 295, + 244 + ], + "score": 0.33, + "content": "\\mathrm { h a r m } \\gets \\mathrm { h a r m } * \\mathrm { m a s k } - ( 1 - \\mathrm { m a s k } ) * \\infty", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 96, + 242, + 227, + 258 + ], + "spans": [ + { + "bbox": [ + 96, + 246, + 105, + 256 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 120, + 242, + 227, + 258 + ], + "score": 1.0, + "content": "zt ← f (arg max(harm))", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 95, + 256, + 126, + 268 + ], + "spans": [ + { + "bbox": [ + 95, + 258, + 106, + 267 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 105, + 256, + 126, + 268 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 93, + 268, + 171, + 281 + ], + "spans": [ + { + "bbox": [ + 93, + 268, + 171, + 281 + ], + "score": 1.0, + "content": "14 return z0 ← zl", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 8, + "bbox_fs": [ + 93, + 84, + 490, + 281 + ] + }, + { + "type": "text", + "bbox": [ + 96, + 312, + 503, + 551 + ], + "lines": [ + { + "bbox": [ + 106, + 311, + 489, + 326 + ], + "spans": [ + { + "bbox": [ + 106, + 311, + 164, + 326 + ], + "score": 1.0, + "content": "Input: Image", + "type": "text" + }, + { + "bbox": [ + 164, + 316, + 171, + 323 + ], + "score": 0.64, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 311, + 196, + 326 + ], + "score": 1.0, + "content": ", label", + "type": "text" + }, + { + "bbox": [ + 197, + 316, + 203, + 325 + ], + "score": 0.73, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 311, + 298, + 326 + ], + "score": 1.0, + "content": ", discretization function", + "type": "text" + }, + { + "bbox": [ + 299, + 314, + 306, + 325 + ], + "score": 0.82, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 311, + 327, + 326 + ], + "score": 1.0, + "content": ", loss", + "type": "text" + }, + { + "bbox": [ + 327, + 313, + 381, + 325 + ], + "score": 0.89, + "content": "\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 311, + 385, + 326 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 385, + 314, + 390, + 324 + ], + "score": 0.43, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 311, + 489, + 326 + ], + "score": 1.0, + "content": "attack steps, parameters", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 133, + 324, + 155, + 335 + ], + "spans": [ + { + "bbox": [ + 133, + 324, + 155, + 335 + ], + "score": 1.0, + "content": "ε, δ", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 334, + 285, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 275, + 348 + ], + "score": 1.0, + "content": "Output: Adversarial input to the network", + "type": "text" + }, + { + "bbox": [ + 276, + 335, + 285, + 345 + ], + "score": 0.81, + "content": "z ^ { \\prime }", + "type": "inline_equation" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 346, + 208, + 357 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 208, + 357 + ], + "score": 0.66, + "content": "\\mathrm { m a s k } g e t M a s k ( x , \\varepsilon )", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 103, + 358, + 302, + 372 + ], + "spans": [ + { + "bbox": [ + 103, + 358, + 302, + 372 + ], + "score": 0.37, + "content": "u ^ { 0 } \\gets \\left( \\mathcal { N } ( \\mathbf { 0 } ^ { k } ; \\mathbf { 1 } ^ { k } ) \\right) ^ { n } * \\mathrm { m a s k - } \\left( 1 - \\mathrm { m a s k } \\right) * \\infty", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 99, + 371, + 139, + 383 + ], + "spans": [ + { + "bbox": [ + 99, + 375, + 105, + 380 + ], + "score": 0.998, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 104, + 371, + 139, + 383 + ], + "score": 1.0, + "content": "T ← 1", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 382, + 187, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 382, + 115, + 394 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 115, + 383, + 122, + 394 + ], + "score": 0.66, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 382, + 187, + 394 + ], + "score": 1.0, + "content": "is one-hot then", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 100, + 391, + 152, + 406 + ], + "spans": [ + { + "bbox": [ + 100, + 398, + 103, + 402 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 113, + 391, + 152, + 406 + ], + "score": 1.0, + "content": "F ← I", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 99, + 403, + 128, + 416 + ], + "spans": [ + { + "bbox": [ + 99, + 408, + 104, + 414 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 103, + 403, + 128, + 416 + ], + "score": 1.0, + "content": "else", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 99, + 413, + 155, + 428 + ], + "spans": [ + { + "bbox": [ + 99, + 419, + 104, + 425 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 107, + 413, + 155, + 428 + ], + "score": 1.0, + "content": "F ← C", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 98, + 425, + 127, + 439 + ], + "spans": [ + { + "bbox": [ + 98, + 429, + 106, + 437 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 101, + 425, + 127, + 439 + ], + "score": 1.0, + "content": "8 end", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 101, + 435, + 185, + 460 + ], + "spans": [ + { + "bbox": [ + 101, + 435, + 185, + 460 + ], + "score": 1.0, + "content": "9 z 0 ← F \u0010 σ \u0010 u 0T \u0011\u0011", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 95, + 456, + 179, + 468 + ], + "spans": [ + { + "bbox": [ + 95, + 458, + 105, + 468 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 105, + 456, + 121, + 468 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 122, + 458, + 147, + 467 + ], + "score": 0.56, + "content": "t \\gets 1", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 456, + 158, + 468 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 159, + 459, + 163, + 467 + ], + "score": 0.36, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 456, + 179, + 468 + ], + "score": 1.0, + "content": "do", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 96, + 466, + 237, + 481 + ], + "spans": [ + { + "bbox": [ + 96, + 471, + 104, + 479 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 120, + 466, + 237, + 481 + ], + "score": 1.0, + "content": "grad ← ∇ut−1 L(θ, zt−1, y)", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 95, + 478, + 238, + 494 + ], + "spans": [ + { + "bbox": [ + 95, + 483, + 105, + 493 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 120, + 478, + 238, + 494 + ], + "score": 1.0, + "content": "ut ← ut−1 + ξ · sign (grad)", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 95, + 491, + 198, + 513 + ], + "spans": [ + { + "bbox": [ + 95, + 498, + 105, + 509 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 118, + 491, + 198, + 513 + ], + "score": 1.0, + "content": "z t ← F \u0010 σ \u0010 u tT \u0011\u0011", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 95, + 510, + 168, + 523 + ], + "spans": [ + { + "bbox": [ + 95, + 514, + 105, + 523 + ], + "score": 1.0, + "content": "14", + "type": "text" + }, + { + "bbox": [ + 119, + 510, + 168, + 523 + ], + "score": 1.0, + "content": "T ← T · δ", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 94, + 523, + 126, + 536 + ], + "spans": [ + { + "bbox": [ + 94, + 525, + 106, + 536 + ], + "score": 1.0, + "content": "15", + "type": "text" + }, + { + "bbox": [ + 105, + 523, + 126, + 536 + ], + "score": 1.0, + "content": "end", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 96, + 535, + 225, + 549 + ], + "spans": [ + { + "bbox": [ + 96, + 535, + 136, + 549 + ], + "score": 1.0, + "content": "16 return", + "type": "text" + }, + { + "bbox": [ + 136, + 536, + 225, + 549 + ], + "score": 0.79, + "content": "z ^ { \\prime } \\gets \\tau ( \\arg \\operatorname* { m a x } ( u _ { i } ^ { l } ) )", + "type": "inline_equation" + } + ], + "index": 36 + } + ], + "index": 27, + "bbox_fs": [ + 94, + 311, + 489, + 549 + ] + }, + { + "type": "table", + "bbox": [ + 185, + 574, + 426, + 660 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 203, + 284, + 393, + 295 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 202, + 282, + 394, + 298 + ], + "spans": [ + { + "bbox": [ + 202, + 282, + 394, + 298 + ], + "score": 1.0, + "content": "Algorithm 2: Discrete Gradient Ascent (DGA)", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "table_caption", + "bbox": [ + 168, + 552, + 428, + 563 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 167, + 550, + 429, + 565 + ], + "spans": [ + { + "bbox": [ + 167, + 550, + 429, + 565 + ], + "score": 1.0, + "content": "Algorithm 3: Logit-Space Projected Gradient Ascent (LS-PGA)", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "table_body", + "bbox": [ + 185, + 574, + 426, + 660 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 185, + 574, + 426, + 660 + ], + "spans": [ + { + "bbox": [ + 185, + 574, + 426, + 660 + ], + "score": 0.971, + "html": "
Modelm8White-boxBlack-box
One-hotOne-hotOne-hot1.00.0011.01.21.21.093.0893.5093.0298.3998.4298.21
ThermometerThermometerThermometer1.00.0011.01.21.21.093.7493.8893.7598.4598.2498.22
", + "type": "table", + "image_path": "a4a5f1d75cd1f4ec8cdc637a606aff4ff207bd741d258c9ac806a1099e0c742f.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 185, + 574, + 426, + 588.3333333333334 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 185, + 588.3333333333334, + 426, + 602.6666666666667 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 185, + 602.6666666666667, + 426, + 617.0000000000001 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 185, + 617.0000000000001, + 426, + 631.3333333333335 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 185, + 631.3333333333335, + 426, + 645.6666666666669 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 185, + 645.6666666666669, + 426, + 660.0000000000002 + ], + "spans": [], + "index": 43 + } + ] + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 108, + 668, + 505, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Table 6: Comparison of adversarial robustness to white-box attacks on MNIST using 16 levels and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 286, + 691 + ], + "score": 1.0, + "content": "with various choices of the hyperparameters", + "type": "text" + }, + { + "bbox": [ + 286, + 679, + 293, + 690 + ], + "score": 0.84, + "content": "\\xi", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 678, + 310, + 691 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 311, + 679, + 317, + 689 + ], + "score": 0.68, + "content": "\\delta", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "for Algorithm 3. The models are evaluated on", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 690, + 503, + 702 + ], + "spans": [ + { + "bbox": [ + 107, + 690, + 503, + 702 + ], + "score": 1.0, + "content": "white-box attacks and on black-box attacks using a vanilla, clean trained model; both use LS-PGA.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45, + "bbox_fs": [ + 106, + 668, + 505, + 702 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "Finally, we also trained on a mix of clean and adversarial examples: this resulted in significantly", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "higher accuracy on clean examples, but decreased accuracy on white-box and black-box attacks", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 222, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 222, + 116 + ], + "score": 1.0, + "content": "compared to Tables 2 and 3.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table", + "bbox": [ + 195, + 131, + 416, + 180 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 195, + 131, + 416, + 180 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 195, + 131, + 416, + 180 + ], + "spans": [ + { + "bbox": [ + 195, + 131, + 416, + 180 + ], + "score": 0.976, + "html": "
ModelCleanFGSMPGD/LS-PGA
Vanilla99.0395.7091.36
One-hot99.0196.1493.77
Thermometer99.1396.1093.70
", + "type": "table", + "image_path": "8dff75a34840b26f9a1b97493fe67a50efc6ec06f78efbecf976fdfc68640b21.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 195, + 131, + 416, + 147.33333333333334 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 195, + 147.33333333333334, + 416, + 163.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 195, + 163.66666666666669, + 416, + 180.00000000000003 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 105, + 188, + 505, + 211 + ], + "lines": [ + { + "bbox": [ + 105, + 187, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 201 + ], + "score": 1.0, + "content": "Table 7: Comparison of adversarial robustness to white-box attacks on MNIST using a mix of clean", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 199, + 212, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 212, + 212 + ], + "score": 1.0, + "content": "and adversarial examples.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "table", + "bbox": [ + 107, + 242, + 518, + 303 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 242, + 518, + 303 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 242, + 518, + 303 + ], + "spans": [ + { + "bbox": [ + 107, + 242, + 518, + 303 + ], + "score": 0.977, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
Vanilla97.8897.8796.9993.0790.9796.46
One-hot98.2898.8398.0895.7395.9697.25
Thermometer98.4598.7098.0896.3595.7296.97
", + "type": "table", + "image_path": "4c0220dfbbe8ed185054cb9d4b4e066db77bf10124e8ae7fee3bffdffe7db687.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 107, + 242, + 518, + 262.3333333333333 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 107, + 262.3333333333333, + 518, + 282.66666666666663 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 107, + 282.66666666666663, + 518, + 302.99999999999994 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 108, + 311, + 504, + 334 + ], + "lines": [ + { + "bbox": [ + 106, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "Table 8: Comparison of adversarial robustness to black-box attacks on MNIST of various models", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 322, + 294, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 294, + 334 + ], + "score": 1.0, + "content": "using a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "table", + "bbox": [ + 135, + 365, + 476, + 506 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 135, + 365, + 476, + 506 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 135, + 365, + 476, + 506 + ], + "spans": [ + { + "bbox": [ + 135, + 365, + 476, + 506 + ], + "score": 0.985, + "html": "
White-boxBlack-box
LevelsCleanPGD/LS-PGAVanilla, CleanVanilla, PGD
One-hot (4) One-hot (8) One-hot (16)99.09 99.10 99.1492.95 92.65 93.0898.23 98.49 98.3995.64 96.37
One-hot (32) One-hot (64)99.06 98.8993.51 93.6398.38 98.3596.26 95.78
Thermometer (4)95.74
99.1192.6298.2395.67
Thermometer (8)99.0893.4598.4495.93
Thermometer(16)99.0793.8898.2495.28
Thermometer (32)99.0294.1498.2495.49
Thermometer (64)99.0094.6298.33
95.71
", + "type": "table", + "image_path": "531a6e3885d10538d93dcfcbbfbe593a9426769fdd4e8b3e745268b79f1325a5.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 135, + 365, + 476, + 412.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 135, + 412.0, + 476, + 459.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 135, + 459.0, + 476, + 506.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "score": 1.0, + "content": "Table 9: Comparison of adversarial robustness on MNIST as the number of levels of discretization", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 524, + 433, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 433, + 537 + ], + "score": 1.0, + "content": "is varied. All models are trained mix of adversarial examples and clean examples.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "title", + "bbox": [ + 106, + 561, + 350, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 349, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 349, + 577 + ], + "score": 1.0, + "content": "D ADDITIONAL EXPERIMENTS ON CIFAR-10", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 506, + 635 + ], + "lines": [ + { + "bbox": [ + 106, + 589, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 505, + 601 + ], + "score": 1.0, + "content": "In this section we list the additional experiments we performed on CIFAR-10. Firstly, we trained", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "models on a mix of both clean and adversarial examples. The results for mixed training are listed in", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Tables 10 and 11; as expected it has lower accuracy on adversarial examples, but higher accuracy on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 623, + 446, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 446, + 635 + ], + "score": 1.0, + "content": "clean examples, compared to training on only adversarial examples (Tables 4 and 5).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "table", + "bbox": [ + 195, + 649, + 415, + 698 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 195, + 649, + 415, + 698 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 195, + 649, + 415, + 698 + ], + "spans": [ + { + "bbox": [ + 195, + 649, + 415, + 698 + ], + "score": 0.974, + "html": "
ModelCleanFGSMPGD/LS-PGA
Vanilla87.1654.5034.71
One-hot92.1958.8758.96
Thermometer92.3266.6065.67
", + "type": "table", + "image_path": "06348496e2bf1cad96212f0782932cc7eac427a4bf8dccac0d15e472f8d81f6d.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 195, + 649, + 415, + 665.3333333333334 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 195, + 665.3333333333334, + 415, + 681.6666666666667 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 195, + 681.6666666666667, + 415, + 698.0000000000001 + ], + "spans": [], + "index": 25 + } + ] + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 706, + 505, + 729 + ], + "lines": [ + { + "bbox": [ + 106, + 706, + 504, + 718 + ], + "spans": [ + { + "bbox": [ + 106, + 706, + 504, + 718 + ], + "score": 1.0, + "content": "Table 10: Comparison of adversarial robustness to white-box attacks on CIFAR-10 of various models", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 717, + 294, + 730 + ], + "spans": [ + { + "bbox": [ + 106, + 717, + 294, + 730 + ], + "score": 1.0, + "content": "using a mix of regular and adversarial training.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "Finally, we also trained on a mix of clean and adversarial examples: this resulted in significantly", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "higher accuracy on clean examples, but decreased accuracy on white-box and black-box attacks", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 222, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 222, + 116 + ], + "score": 1.0, + "content": "compared to Tables 2 and 3.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 116 + ] + }, + { + "type": "table", + "bbox": [ + 195, + 131, + 416, + 180 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 195, + 131, + 416, + 180 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 195, + 131, + 416, + 180 + ], + "spans": [ + { + "bbox": [ + 195, + 131, + 416, + 180 + ], + "score": 0.976, + "html": "
ModelCleanFGSMPGD/LS-PGA
Vanilla99.0395.7091.36
One-hot99.0196.1493.77
Thermometer99.1396.1093.70
", + "type": "table", + "image_path": "8dff75a34840b26f9a1b97493fe67a50efc6ec06f78efbecf976fdfc68640b21.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 195, + 131, + 416, + 147.33333333333334 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 195, + 147.33333333333334, + 416, + 163.66666666666669 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 195, + 163.66666666666669, + 416, + 180.00000000000003 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 105, + 188, + 505, + 211 + ], + "lines": [ + { + "bbox": [ + 105, + 187, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 201 + ], + "score": 1.0, + "content": "Table 7: Comparison of adversarial robustness to white-box attacks on MNIST using a mix of clean", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 199, + 212, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 212, + 212 + ], + "score": 1.0, + "content": "and adversarial examples.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 187, + 505, + 212 + ] + }, + { + "type": "table", + "bbox": [ + 107, + 242, + 518, + 303 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 242, + 518, + 303 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 242, + 518, + 303 + ], + "spans": [ + { + "bbox": [ + 107, + 242, + 518, + 303 + ], + "score": 0.977, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
Vanilla97.8897.8796.9993.0790.9796.46
One-hot98.2898.8398.0895.7395.9697.25
Thermometer98.4598.7098.0896.3595.7296.97
", + "type": "table", + "image_path": "4c0220dfbbe8ed185054cb9d4b4e066db77bf10124e8ae7fee3bffdffe7db687.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 107, + 242, + 518, + 262.3333333333333 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 107, + 262.3333333333333, + 518, + 282.66666666666663 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 107, + 282.66666666666663, + 518, + 302.99999999999994 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 108, + 311, + 504, + 334 + ], + "lines": [ + { + "bbox": [ + 106, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 106, + 310, + 505, + 323 + ], + "score": 1.0, + "content": "Table 8: Comparison of adversarial robustness to black-box attacks on MNIST of various models", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 322, + 294, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 294, + 334 + ], + "score": 1.0, + "content": "using a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 310, + 505, + 334 + ] + }, + { + "type": "table", + "bbox": [ + 135, + 365, + 476, + 506 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 135, + 365, + 476, + 506 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 135, + 365, + 476, + 506 + ], + "spans": [ + { + "bbox": [ + 135, + 365, + 476, + 506 + ], + "score": 0.985, + "html": "
White-boxBlack-box
LevelsCleanPGD/LS-PGAVanilla, CleanVanilla, PGD
One-hot (4) One-hot (8) One-hot (16)99.09 99.10 99.1492.95 92.65 93.0898.23 98.49 98.3995.64 96.37
One-hot (32) One-hot (64)99.06 98.8993.51 93.6398.38 98.3596.26 95.78
Thermometer (4)95.74
99.1192.6298.2395.67
Thermometer (8)99.0893.4598.4495.93
Thermometer(16)99.0793.8898.2495.28
Thermometer (32)99.0294.1498.2495.49
Thermometer (64)99.0094.6298.33
95.71
", + "type": "table", + "image_path": "531a6e3885d10538d93dcfcbbfbe593a9426769fdd4e8b3e745268b79f1325a5.jpg" + } + ] + } + ], + "index": 14, + "virtual_lines": [ + { + "bbox": [ + 135, + 365, + 476, + 412.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 135, + 412.0, + 476, + 459.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 135, + 459.0, + 476, + 506.0 + ], + "spans": [], + "index": 15 + } + ] + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 505, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 526 + ], + "score": 1.0, + "content": "Table 9: Comparison of adversarial robustness on MNIST as the number of levels of discretization", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 524, + 433, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 433, + 537 + ], + "score": 1.0, + "content": "is varied. All models are trained mix of adversarial examples and clean examples.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 512, + 505, + 537 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 561, + 350, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 349, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 349, + 577 + ], + "score": 1.0, + "content": "D ADDITIONAL EXPERIMENTS ON CIFAR-10", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 506, + 635 + ], + "lines": [ + { + "bbox": [ + 106, + 589, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 505, + 601 + ], + "score": 1.0, + "content": "In this section we list the additional experiments we performed on CIFAR-10. Firstly, we trained", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "models on a mix of both clean and adversarial examples. The results for mixed training are listed in", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Tables 10 and 11; as expected it has lower accuracy on adversarial examples, but higher accuracy on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 623, + 446, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 623, + 446, + 635 + ], + "score": 1.0, + "content": "clean examples, compared to training on only adversarial examples (Tables 4 and 5).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5, + "bbox_fs": [ + 106, + 589, + 505, + 635 + ] + }, + { + "type": "table", + "bbox": [ + 195, + 649, + 415, + 698 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 195, + 649, + 415, + 698 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 195, + 649, + 415, + 698 + ], + "spans": [ + { + "bbox": [ + 195, + 649, + 415, + 698 + ], + "score": 0.974, + "html": "
ModelCleanFGSMPGD/LS-PGA
Vanilla87.1654.5034.71
One-hot92.1958.8758.96
Thermometer92.3266.6065.67
", + "type": "table", + "image_path": "06348496e2bf1cad96212f0782932cc7eac427a4bf8dccac0d15e472f8d81f6d.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 195, + 649, + 415, + 665.3333333333334 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 195, + 665.3333333333334, + 415, + 681.6666666666667 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 195, + 681.6666666666667, + 415, + 698.0000000000001 + ], + "spans": [], + "index": 25 + } + ] + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 706, + 505, + 729 + ], + "lines": [ + { + "bbox": [ + 106, + 706, + 504, + 718 + ], + "spans": [ + { + "bbox": [ + 106, + 706, + 504, + 718 + ], + "score": 1.0, + "content": "Table 10: Comparison of adversarial robustness to white-box attacks on CIFAR-10 of various models", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 717, + 294, + 730 + ], + "spans": [ + { + "bbox": [ + 106, + 717, + 294, + 730 + ], + "score": 1.0, + "content": "using a mix of regular and adversarial training.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 106, + 706, + 504, + 730 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 519, + 141 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 519, + 141 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 80, + 519, + 141 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 519, + 141 + ], + "score": 0.98, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
Vanilla83.6282.0674.3152.8358.7365.24
One-hot88.1675.1175.4961.8959.1769.73
Thermometer87.5075.9174.8461.3958.5168.22
", + "type": "table", + "image_path": "298c131e1d0daa7174cd2fa7173a98273278f14f3291b7ea0bf1b7b11f4134f5.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 519, + 100.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 100.33333333333333, + 519, + 120.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 120.66666666666666, + 519, + 141.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 149, + 504, + 171 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "Table 11: Comparison of adversarial robustness to black-box attacks on CIFAR-10 of various models", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 159, + 294, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 294, + 172 + ], + "score": 1.0, + "content": "using a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 189, + 506, + 257 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "score": 1.0, + "content": "In order to explore whether the number of levels of discretization affected the performance of the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "model, we trained several models which varied this number. As expected, we found that models with", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "score": 1.0, + "content": "fewer levels had worse accuracy on clean examples, likely because there was not enough information", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "score": 1.0, + "content": "to correctly classify the image, but greater robustness to adversarial examples, likely because larger", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 234, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 506, + 246 + ], + "score": 1.0, + "content": "buckets mean a greater chance that a given perturbation will not yield any change in input to the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 245, + 470, + 257 + ], + "spans": [ + { + "bbox": [ + 106, + 245, + 470, + 257 + ], + "score": 1.0, + "content": "network (Xu et al., 2017). Results can be seen in Tables 12, and are visualized in Figure 4.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5 + }, + { + "type": "table", + "bbox": [ + 136, + 266, + 475, + 419 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 136, + 266, + 475, + 419 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 136, + 266, + 475, + 419 + ], + "spans": [ + { + "bbox": [ + 136, + 266, + 475, + 419 + ], + "score": 0.983, + "html": "
White-boxBlack-box
LevelsCleanPGD/LS-PGAVanilla, CleanVanilla, PGD
Vanilla (Madry)87.350.0085.6067.00
One-hot (4)One-hot (8)One-hot (16)One-hot (32)One-hot (64)83.6785.6288.5488.5689.6359.5961.9867.8367.8265.6383.0384.9286.0185.6986.9472.0372.1061.9266.6465.77
Thermometer (4)Thermometer (8)Thermometer (16)Thermometer (32)Thermometer (64)84.4785.1789.8890.3089.9561.8867.2379.1672.9169.3783.6483.4188.2586.0683.8572.9671.1167.9659.3251.82
", + "type": "table", + "image_path": "8e511db505e6d2bf59d63cc10802c009a296b34356ddb7d347df476ba1b1b1eb.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 136, + 266, + 475, + 317.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 136, + 317.0, + 475, + 368.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 136, + 368.0, + 475, + 419.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 427, + 504, + 451 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 426, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 440 + ], + "score": 1.0, + "content": "Table 12: Comparison of adversarial robustness on CIFAR-10 as the number of levels of discretiza-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 438, + 375, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 375, + 451 + ], + "score": 1.0, + "content": "tion is varied. All models are trained only on adversarial examples.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + } + ], + "index": 13.25 + }, + { + "type": "title", + "bbox": [ + 108, + 470, + 284, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 285, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 285, + 485 + ], + "score": 1.0, + "content": "E EXPERIMENTS ON CIFAR-100", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 495, + 506, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 388, + 507 + ], + "score": 1.0, + "content": "We list the experimental results on CIFAR-100 in Table 13. We choose", + "type": "text" + }, + { + "bbox": [ + 389, + 496, + 426, + 507 + ], + "score": 0.91, + "content": "\\xi = 0 . 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 495, + 443, + 507 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 443, + 496, + 476, + 506 + ], + "score": 0.9, + "content": "\\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "for the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "LS-PGA attack hyperparameters. For the discretized models, we used 16 levels. All adversarially", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 517, + 396, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 396, + 529 + ], + "score": 1.0, + "content": "trained models were trained on a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "table", + "bbox": [ + 106, + 538, + 516, + 635 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 538, + 516, + 635 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 538, + 516, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 516, + 635 + ], + "score": 0.984, + "html": "
TargetSourceCleanWhite-box PGD/LS-PGABlack-box
Vanilla, Clean-trainedVanilla, PGD-trained
evaaaVanilla One-hot74.3200.49.40
Thermometer73.2516.5555.7219.33
74.4416.5050.3318.49
Vanilla64.466.027.4611.77
AOne-hot66.5425.1163.0942.46
Thermometer68.4428.1463.2141.97
", + "type": "table", + "image_path": "356228d43d1253142c4279ed0548c077ec6b9be7062e52e591f0b11f6be8dab7.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 106, + 538, + 516, + 570.3333333333334 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 106, + 570.3333333333334, + 516, + 602.6666666666667 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 106, + 602.6666666666667, + 516, + 635.0000000000001 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 642, + 505, + 665 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 642, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 655 + ], + "score": 1.0, + "content": "Table 13: Comparison of adversarial robustness on CIFAR-100. All adversarially trained models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 653, + 334, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 334, + 666 + ], + "score": 1.0, + "content": "were trained on a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "index": 22.25 + }, + { + "type": "title", + "bbox": [ + 108, + 685, + 257, + 698 + ], + "lines": [ + { + "bbox": [ + 104, + 684, + 258, + 699 + ], + "spans": [ + { + "bbox": [ + 104, + 684, + 258, + 699 + ], + "score": 1.0, + "content": "F EXPERIMENTS ON SVHN", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "We list the experimental results on SVHN in Table 14. All adversarially trained models were trained", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 721, + 227, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 227, + 732 + ], + "score": 1.0, + "content": "only on adversarial examples.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 519, + 141 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 519, + 141 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 80, + 519, + 141 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 519, + 141 + ], + "score": 0.98, + "html": "
Source TargetCleanAdv. train
VanillaOne-hotThermometerVanillaOne-hotThermometer
Vanilla83.6282.0674.3152.8358.7365.24
One-hot88.1675.1175.4961.8959.1769.73
Thermometer87.5075.9174.8461.3958.5168.22
", + "type": "table", + "image_path": "298c131e1d0daa7174cd2fa7173a98273278f14f3291b7ea0bf1b7b11f4134f5.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 519, + 100.33333333333333 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 100.33333333333333, + 519, + 120.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 120.66666666666666, + 519, + 141.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 149, + 504, + 171 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 149, + 505, + 160 + ], + "score": 1.0, + "content": "Table 11: Comparison of adversarial robustness to black-box attacks on CIFAR-10 of various models", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 159, + 294, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 294, + 172 + ], + "score": 1.0, + "content": "using a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 106, + 189, + 506, + 257 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "score": 1.0, + "content": "In order to explore whether the number of levels of discretization affected the performance of the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "model, we trained several models which varied this number. As expected, we found that models with", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 225 + ], + "score": 1.0, + "content": "fewer levels had worse accuracy on clean examples, likely because there was not enough information", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 236 + ], + "score": 1.0, + "content": "to correctly classify the image, but greater robustness to adversarial examples, likely because larger", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 234, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 506, + 246 + ], + "score": 1.0, + "content": "buckets mean a greater chance that a given perturbation will not yield any change in input to the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 245, + 470, + 257 + ], + "spans": [ + { + "bbox": [ + 106, + 245, + 470, + 257 + ], + "score": 1.0, + "content": "network (Xu et al., 2017). Results can be seen in Tables 12, and are visualized in Figure 4.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 190, + 506, + 257 + ] + }, + { + "type": "table", + "bbox": [ + 136, + 266, + 475, + 419 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 136, + 266, + 475, + 419 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 136, + 266, + 475, + 419 + ], + "spans": [ + { + "bbox": [ + 136, + 266, + 475, + 419 + ], + "score": 0.983, + "html": "
White-boxBlack-box
LevelsCleanPGD/LS-PGAVanilla, CleanVanilla, PGD
Vanilla (Madry)87.350.0085.6067.00
One-hot (4)One-hot (8)One-hot (16)One-hot (32)One-hot (64)83.6785.6288.5488.5689.6359.5961.9867.8367.8265.6383.0384.9286.0185.6986.9472.0372.1061.9266.6465.77
Thermometer (4)Thermometer (8)Thermometer (16)Thermometer (32)Thermometer (64)84.4785.1789.8890.3089.9561.8867.2379.1672.9169.3783.6483.4188.2586.0683.8572.9671.1167.9659.3251.82
", + "type": "table", + "image_path": "8e511db505e6d2bf59d63cc10802c009a296b34356ddb7d347df476ba1b1b1eb.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 136, + 266, + 475, + 317.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 136, + 317.0, + 475, + 368.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 136, + 368.0, + 475, + 419.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 427, + 504, + 451 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 426, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 440 + ], + "score": 1.0, + "content": "Table 12: Comparison of adversarial robustness on CIFAR-10 as the number of levels of discretiza-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 438, + 375, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 375, + 451 + ], + "score": 1.0, + "content": "tion is varied. All models are trained only on adversarial examples.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + } + ], + "index": 13.25 + }, + { + "type": "title", + "bbox": [ + 108, + 470, + 284, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 285, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 285, + 485 + ], + "score": 1.0, + "content": "E EXPERIMENTS ON CIFAR-100", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 495, + 506, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 388, + 507 + ], + "score": 1.0, + "content": "We list the experimental results on CIFAR-100 in Table 13. We choose", + "type": "text" + }, + { + "bbox": [ + 389, + 496, + 426, + 507 + ], + "score": 0.91, + "content": "\\xi = 0 . 0 1", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 495, + 443, + 507 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 443, + 496, + 476, + 506 + ], + "score": 0.9, + "content": "\\delta = 1 . 2", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "for the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "LS-PGA attack hyperparameters. For the discretized models, we used 16 levels. All adversarially", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 517, + 396, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 396, + 529 + ], + "score": 1.0, + "content": "trained models were trained on a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 495, + 505, + 529 + ] + }, + { + "type": "table", + "bbox": [ + 106, + 538, + 516, + 635 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 538, + 516, + 635 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 538, + 516, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 516, + 635 + ], + "score": 0.984, + "html": "
TargetSourceCleanWhite-box PGD/LS-PGABlack-box
Vanilla, Clean-trainedVanilla, PGD-trained
evaaaVanilla One-hot74.3200.49.40
Thermometer73.2516.5555.7219.33
74.4416.5050.3318.49
Vanilla64.466.027.4611.77
AOne-hot66.5425.1163.0942.46
Thermometer68.4428.1463.2141.97
", + "type": "table", + "image_path": "356228d43d1253142c4279ed0548c077ec6b9be7062e52e591f0b11f6be8dab7.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 106, + 538, + 516, + 570.3333333333334 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 106, + 570.3333333333334, + 516, + 602.6666666666667 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 106, + 602.6666666666667, + 516, + 635.0000000000001 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 107, + 642, + 505, + 665 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 642, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 655 + ], + "score": 1.0, + "content": "Table 13: Comparison of adversarial robustness on CIFAR-100. All adversarially trained models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 653, + 334, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 334, + 666 + ], + "score": 1.0, + "content": "were trained on a mix of clean and adversarial examples.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + } + ], + "index": 22.25 + }, + { + "type": "title", + "bbox": [ + 108, + 685, + 257, + 698 + ], + "lines": [ + { + "bbox": [ + 104, + 684, + 258, + 699 + ], + "spans": [ + { + "bbox": [ + 104, + 684, + 258, + 699 + ], + "score": 1.0, + "content": "F EXPERIMENTS ON SVHN", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "We list the experimental results on SVHN in Table 14. All adversarially trained models were trained", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 721, + 227, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 227, + 732 + ], + "score": 1.0, + "content": "only on adversarial examples.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 516, + 176 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 516, + 176 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 516, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 516, + 176 + ], + "score": 0.983, + "html": "
TargetSourceWhite-boxBlack-box
CleanPGD/LS-PGAVanilla, Clean-trainedVanilla, PGD-trained
ereaVanilla97.906.9973.9442.04
One-hot97.5956.0275.7741.59
Thermometer97.8756.3778.0441.69
Vanilla94.7959.6381.2446.77
AOne-hot95.1287.3483.8443.40
Thermometer97.7494.7784.9748.67
", + "type": "table", + "image_path": "7fe342043f5eafcec1d51ce39a63be8d4aeb4ad8e0b06c44b77d430e2dcfbe5c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 516, + 112.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 112.0, + 516, + 144.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 144.0, + 516, + 176.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 185, + 184, + 422, + 196 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 185, + 183, + 423, + 197 + ], + "spans": [ + { + "bbox": [ + 185, + 183, + 423, + 197 + ], + "score": 1.0, + "content": "Table 14: Comparison of adversarial robustness on SVHN.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 108, + 216, + 267, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 216, + 268, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 268, + 230 + ], + "score": 1.0, + "content": "G SUPPLEMENTARY FIGURES", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "image", + "bbox": [ + 117, + 269, + 494, + 411 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 240, + 505, + 263 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 239, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 253 + ], + "score": 1.0, + "content": "In Figure 4 we plot the effect of increasing the levels of discretization for the MNIST and CIFAR-10", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 249, + 144, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 144, + 264 + ], + "score": 1.0, + "content": "datasets.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "image_body", + "bbox": [ + 117, + 269, + 494, + 411 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 269, + 494, + 411 + ], + "spans": [ + { + "bbox": [ + 117, + 269, + 494, + 411 + ], + "score": 0.968, + "type": "image", + "image_path": "a8ebdd6c09562c3bff5cb9abe039c9d87ccd31689672f17c3dd1b5d3353ae4be.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 117, + 269, + 494, + 316.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 117, + 316.3333333333333, + 494, + 363.66666666666663 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 117, + 363.66666666666663, + 494, + 410.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 420, + 505, + 465 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "Figure 4: The effect of increasing the number of distinct discretization levels on the accuracy of the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 432, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 505, + 443 + ], + "score": 1.0, + "content": "model on MNIST and CIFAR-10. (4a) shows the accuracy on on MNIST for discretized models", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "score": 1.0, + "content": "trained on a mix of legitimate and adversarial examples. (4b) shows the accuracy on CIFAR-10 for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 453, + 334, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 334, + 465 + ], + "score": 1.0, + "content": "discretized models trained only on adversarial examples.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 108, + 477, + 502, + 511 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 504, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 504, + 489 + ], + "score": 1.0, + "content": "In Figure 5 we plot the convergence rate of clean trained and adversarially trained models on the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 488, + 504, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 504, + 501 + ], + "score": 1.0, + "content": "CIFAR-10 dataset. Note that thermometer encoded inputs converge much faster in accuracy on both", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 499, + 222, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 499, + 222, + 512 + ], + "score": 1.0, + "content": "clean and adversarial inputs.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 108, + 516, + 503, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "Figure 6 plots the norm of the gradient as a function of the number of iterations of the attack on", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 527, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 539 + ], + "score": 1.0, + "content": "MNIST. Note that the gradient vanishes at around 40 iterations, which coincides with the loss stabi-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 538, + 181, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 181, + 551 + ], + "score": 1.0, + "content": "lizing in Figure 3.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "In Figure 7, we create a linear interpolation between a clean image and an adversarial example, and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "then continue to extrapolate along this line, evaluating probability of each class at each point. In", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 577, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 588 + ], + "score": 1.0, + "content": "models trained on unquantized inputs, the class probabilities are all mostly piecewise linear in both", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "the positive and negative directions. In contrast, the discretized model has a much more jagged and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 598, + 171, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 171, + 613 + ], + "score": 1.0, + "content": "irregular shape.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 397, + 628 + ], + "score": 1.0, + "content": "In Figure 8, we plot the error for different models on various values of", + "type": "text" + }, + { + "bbox": [ + 397, + 618, + 403, + 626 + ], + "score": 0.66, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 616, + 505, + 628 + ], + "score": 1.0, + "content": ". The discretized models", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "are extremely robust to all values less-than-or-equal-to the values that they have been exposed to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "during training. However, beyond this threshold, discretized models collapse immediately, while", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "real-valued models still maintain some semblance of robustness. This exposes a weakness of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "discretization approach; the same nonlinearity that helps it learn to become robust to all attacks it", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 671, + 403, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 403, + 684 + ], + "score": 1.0, + "content": "sees during training-time causes its behavior is unpredictable beyond that.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "However, we believe that the fact that the performance of thermometer-encoded models degrades", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "more quickly than that of vanilla models beyond the training epsilon is a significant weakness in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "practice, but no worse than other defenses. The “standard setting” for the adversarial example prob-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "lem (in which we constrain the L-infinity norm of the perturbed image to an epsilon ball around the", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 80, + 516, + 176 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 80, + 516, + 176 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 516, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 516, + 176 + ], + "score": 0.983, + "html": "
TargetSourceWhite-boxBlack-box
CleanPGD/LS-PGAVanilla, Clean-trainedVanilla, PGD-trained
ereaVanilla97.906.9973.9442.04
One-hot97.5956.0275.7741.59
Thermometer97.8756.3778.0441.69
Vanilla94.7959.6381.2446.77
AOne-hot95.1287.3483.8443.40
Thermometer97.7494.7784.9748.67
", + "type": "table", + "image_path": "7fe342043f5eafcec1d51ce39a63be8d4aeb4ad8e0b06c44b77d430e2dcfbe5c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 80, + 516, + 112.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 112.0, + 516, + 144.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 144.0, + 516, + 176.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 185, + 184, + 422, + 196 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 185, + 183, + 423, + 197 + ], + "spans": [ + { + "bbox": [ + 185, + 183, + 423, + 197 + ], + "score": 1.0, + "content": "Table 14: Comparison of adversarial robustness on SVHN.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 108, + 216, + 267, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 216, + 268, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 268, + 230 + ], + "score": 1.0, + "content": "G SUPPLEMENTARY FIGURES", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "image", + "bbox": [ + 117, + 269, + 494, + 411 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 106, + 240, + 505, + 263 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 239, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 253 + ], + "score": 1.0, + "content": "In Figure 4 we plot the effect of increasing the levels of discretization for the MNIST and CIFAR-10", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 249, + 144, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 144, + 264 + ], + "score": 1.0, + "content": "datasets.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "image_body", + "bbox": [ + 117, + 269, + 494, + 411 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 269, + 494, + 411 + ], + "spans": [ + { + "bbox": [ + 117, + 269, + 494, + 411 + ], + "score": 0.968, + "type": "image", + "image_path": "a8ebdd6c09562c3bff5cb9abe039c9d87ccd31689672f17c3dd1b5d3353ae4be.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 117, + 269, + 494, + 316.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 117, + 316.3333333333333, + 494, + 363.66666666666663 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 117, + 363.66666666666663, + 494, + 410.99999999999994 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 420, + 505, + 465 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 433 + ], + "score": 1.0, + "content": "Figure 4: The effect of increasing the number of distinct discretization levels on the accuracy of the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 432, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 505, + 443 + ], + "score": 1.0, + "content": "model on MNIST and CIFAR-10. (4a) shows the accuracy on on MNIST for discretized models", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "score": 1.0, + "content": "trained on a mix of legitimate and adversarial examples. (4b) shows the accuracy on CIFAR-10 for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 453, + 334, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 334, + 465 + ], + "score": 1.0, + "content": "discretized models trained only on adversarial examples.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 108, + 477, + 502, + 511 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 504, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 504, + 489 + ], + "score": 1.0, + "content": "In Figure 5 we plot the convergence rate of clean trained and adversarially trained models on the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 488, + 504, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 504, + 501 + ], + "score": 1.0, + "content": "CIFAR-10 dataset. Note that thermometer encoded inputs converge much faster in accuracy on both", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 499, + 222, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 499, + 222, + 512 + ], + "score": 1.0, + "content": "clean and adversarial inputs.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 106, + 478, + 504, + 512 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 516, + 503, + 549 + ], + "lines": [ + { + "bbox": [ + 105, + 516, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 528 + ], + "score": 1.0, + "content": "Figure 6 plots the norm of the gradient as a function of the number of iterations of the attack on", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 527, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 539 + ], + "score": 1.0, + "content": "MNIST. Note that the gradient vanishes at around 40 iterations, which coincides with the loss stabi-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 538, + 181, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 181, + 551 + ], + "score": 1.0, + "content": "lizing in Figure 3.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 516, + 505, + 551 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "In Figure 7, we create a linear interpolation between a clean image and an adversarial example, and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 505, + 578 + ], + "score": 1.0, + "content": "then continue to extrapolate along this line, evaluating probability of each class at each point. In", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 577, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 588 + ], + "score": 1.0, + "content": "models trained on unquantized inputs, the class probabilities are all mostly piecewise linear in both", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "the positive and negative directions. In contrast, the discretized model has a much more jagged and", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 598, + 171, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 171, + 613 + ], + "score": 1.0, + "content": "irregular shape.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 555, + 506, + 613 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 615, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 397, + 628 + ], + "score": 1.0, + "content": "In Figure 8, we plot the error for different models on various values of", + "type": "text" + }, + { + "bbox": [ + 397, + 618, + 403, + 626 + ], + "score": 0.66, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 616, + 505, + 628 + ], + "score": 1.0, + "content": ". The discretized models", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "are extremely robust to all values less-than-or-equal-to the values that they have been exposed to", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "during training. However, beyond this threshold, discretized models collapse immediately, while", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "score": 1.0, + "content": "real-valued models still maintain some semblance of robustness. This exposes a weakness of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "discretization approach; the same nonlinearity that helps it learn to become robust to all attacks it", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 671, + 403, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 403, + 684 + ], + "score": 1.0, + "content": "sees during training-time causes its behavior is unpredictable beyond that.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 616, + 506, + 684 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "However, we believe that the fact that the performance of thermometer-encoded models degrades", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "more quickly than that of vanilla models beyond the training epsilon is a significant weakness in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 721 + ], + "score": 1.0, + "content": "practice, but no worse than other defenses. The “standard setting” for the adversarial example prob-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "lem (in which we constrain the L-infinity norm of the perturbed image to an epsilon ball around the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "original image) was designed to ensure that any adversarially-perturbed image is still recognizable", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "score": 1.0, + "content": "as its original image by a human. However, this artificial constraint excludes many other poten-", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 539, + 504, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 504, + 551 + ], + "score": 1.0, + "content": "tial attacks that also result in human-recognizable images. State-of-the art defenses in the standard", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 550, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 562 + ], + "score": 1.0, + "content": "setting can still be easily defeated by non-standard attacks; for an example of this, see appendix A", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 559, + 507, + 574 + ], + "spans": [ + { + "bbox": [ + 104, + 559, + 507, + 574 + ], + "score": 1.0, + "content": "of ICLR submission “Adversarial Spheres”. A “larger epsilon” attack is just one special case of a", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "“non-standard” attack. If we permit non-standard attacks, a fair comparison would show that all cur-", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "rent approaches are easily breakable. There is nothing special about the “larger epsilon” attack that", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "makes a vulnerability to this non-standard attack in particular more problematic than vulnerabilities", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 605, + 226, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 226, + 617 + ], + "score": 1.0, + "content": "to other non-standard attacks.", + "type": "text", + "cross_page": true + } + ], + "index": 21 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 688, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 502, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 502, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 502, + 234 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 502, + 234 + ], + "score": 0.969, + "type": "image", + "image_path": "f54afb62fd3df9546cc33fc79e2f193ef3b221d2ab127c90e7d8126cc8b84224.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 502, + 130.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 130.66666666666666, + 502, + 182.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 182.33333333333331, + 502, + 233.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 243, + 505, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 243, + 504, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 504, + 255 + ], + "score": 1.0, + "content": "Figure 5: Comparison of the convergence rate of various adversarially trained models on the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "CIFAR-10 dataset. The discretized models use 16 levels per color channel. (5a) shows the ac-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "curacy on clean examples, while (5b) shows the accuracy on white-box PGD/LS-PGA examples, in", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 277, + 173, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 173, + 288 + ], + "score": 1.0, + "content": "wall-clock time.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "image", + "bbox": [ + 108, + 300, + 499, + 453 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 300, + 499, + 453 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 300, + 499, + 453 + ], + "spans": [ + { + "bbox": [ + 108, + 300, + 499, + 453 + ], + "score": 0.969, + "type": "image", + "image_path": "26d31999144179f1b87e876690579d277bda1d16fe9adca44b3657d0a5e4dc09.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 108, + 300, + 499, + 351.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 351.0, + 499, + 402.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 108, + 402.0, + 499, + 453.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 462, + 505, + 496 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Figure 6: Gradient norm for iterated white-box attacks on various models on a randomly chosen", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 472, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 486 + ], + "score": 1.0, + "content": "data point from MNIST. (6a) shows the gradient norm on discretized models as a function of steps", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 484, + 500, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 500, + 496 + ], + "score": 1.0, + "content": "of LS-PGA, while (6b) shows the gradient norm on a vanilla model as a function of steps of PGD.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 505, + 616 + ], + "lines": [ + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "original image) was designed to ensure that any adversarially-perturbed image is still recognizable", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 541 + ], + "score": 1.0, + "content": "as its original image by a human. However, this artificial constraint excludes many other poten-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 539, + 504, + 551 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 504, + 551 + ], + "score": 1.0, + "content": "tial attacks that also result in human-recognizable images. State-of-the art defenses in the standard", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 550, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 562 + ], + "score": 1.0, + "content": "setting can still be easily defeated by non-standard attacks; for an example of this, see appendix A", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 559, + 507, + 574 + ], + "spans": [ + { + "bbox": [ + 104, + 559, + 507, + 574 + ], + "score": 1.0, + "content": "of ICLR submission “Adversarial Spheres”. A “larger epsilon” attack is just one special case of a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "“non-standard” attack. If we permit non-standard attacks, a fair comparison would show that all cur-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "rent approaches are easily breakable. There is nothing special about the “larger epsilon” attack that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "makes a vulnerability to this non-standard attack in particular more problematic than vulnerabilities", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 605, + 226, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 226, + 617 + ], + "score": 1.0, + "content": "to other non-standard attacks.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "In Figures 9, 10 , 11, 12 , 13 and 14 we plot several examples of church-window plots for MNIST", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "(Goodfellow et al., 2014). Each plot is crafted by taking several test-set images, calculating the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 644, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 655 + ], + "score": 1.0, + "content": "vector corresponding to an adversarial attack on each image, and then choosing an additional random", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "orthogonal direction. In each plot, the clean image is at the center and corresponds to the color white,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 120, + 678 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 667, + 128, + 675 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 666, + 478, + 678 + ], + "score": 1.0, + "content": "-axis corresponds to the magnitude of a perturbation in the adversarial direction, and the", + "type": "text" + }, + { + "bbox": [ + 478, + 667, + 484, + 677 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "-axis", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "corresponds to the magnitude of a perturbation in the orthogonal direction. Note that we use the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "score": 1.0, + "content": "same random seed to generate the test set examples and the adversarial directions across different", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 698, + 196, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 196, + 711 + ], + "score": 1.0, + "content": "church-window plots.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "15", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 79, + 502, + 234 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 79, + 502, + 234 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 79, + 502, + 234 + ], + "spans": [ + { + "bbox": [ + 108, + 79, + 502, + 234 + ], + "score": 0.969, + "type": "image", + "image_path": "f54afb62fd3df9546cc33fc79e2f193ef3b221d2ab127c90e7d8126cc8b84224.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 79, + 502, + 130.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 130.66666666666666, + 502, + 182.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 182.33333333333331, + 502, + 233.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 243, + 505, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 243, + 504, + 255 + ], + "spans": [ + { + "bbox": [ + 106, + 243, + 504, + 255 + ], + "score": 1.0, + "content": "Figure 5: Comparison of the convergence rate of various adversarially trained models on the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "CIFAR-10 dataset. The discretized models use 16 levels per color channel. (5a) shows the ac-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 505, + 278 + ], + "score": 1.0, + "content": "curacy on clean examples, while (5b) shows the accuracy on white-box PGD/LS-PGA examples, in", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 277, + 173, + 288 + ], + "spans": [ + { + "bbox": [ + 106, + 277, + 173, + 288 + ], + "score": 1.0, + "content": "wall-clock time.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "image", + "bbox": [ + 108, + 300, + 499, + 453 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 300, + 499, + 453 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 108, + 300, + 499, + 453 + ], + "spans": [ + { + "bbox": [ + 108, + 300, + 499, + 453 + ], + "score": 0.969, + "type": "image", + "image_path": "26d31999144179f1b87e876690579d277bda1d16fe9adca44b3657d0a5e4dc09.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 108, + 300, + 499, + 351.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 351.0, + 499, + 402.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 108, + 402.0, + 499, + 453.0 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 462, + 505, + 496 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "Figure 6: Gradient norm for iterated white-box attacks on various models on a randomly chosen", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 472, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 486 + ], + "score": 1.0, + "content": "data point from MNIST. (6a) shows the gradient norm on discretized models as a function of steps", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 484, + 500, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 500, + 496 + ], + "score": 1.0, + "content": "of LS-PGA, while (6b) shows the gradient norm on a vanilla model as a function of steps of PGD.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 505, + 616 + ], + "lines": [], + "index": 17, + "bbox_fs": [ + 104, + 517, + 507, + 617 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 621, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "In Figures 9, 10 , 11, 12 , 13 and 14 we plot several examples of church-window plots for MNIST", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "(Goodfellow et al., 2014). Each plot is crafted by taking several test-set images, calculating the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 644, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 655 + ], + "score": 1.0, + "content": "vector corresponding to an adversarial attack on each image, and then choosing an additional random", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "orthogonal direction. In each plot, the clean image is at the center and corresponds to the color white,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 120, + 678 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 667, + 128, + 675 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 666, + 478, + 678 + ], + "score": 1.0, + "content": "-axis corresponds to the magnitude of a perturbation in the adversarial direction, and the", + "type": "text" + }, + { + "bbox": [ + 478, + 667, + 484, + 677 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "-axis", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "corresponds to the magnitude of a perturbation in the orthogonal direction. Note that we use the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 699 + ], + "score": 1.0, + "content": "same random seed to generate the test set examples and the adversarial directions across different", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 698, + 196, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 196, + 711 + ], + "score": 1.0, + "content": "church-window plots.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 621, + 506, + 711 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 118, + 150, + 504, + 306 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 150, + 504, + 306 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 150, + 504, + 306 + ], + "spans": [ + { + "bbox": [ + 118, + 150, + 504, + 306 + ], + "score": 0.946, + "type": "image", + "image_path": "0604ba8d594b2cc20ab2cd825ddd95d7f109060c47f4da6bd6c0c716b6cb48a4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 150, + 504, + 202.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 202.0, + 504, + 254.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 254.0, + 504, + 306.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 315, + 506, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "Figure 7: Linear extrapolation plot as in Goodfellow et al. (2014) for MNIST. (7a) shows the behav-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 325, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 340 + ], + "score": 1.0, + "content": "ior of a vanilla model while (7b) for a discretized model using 16 levels and thermometer encoding.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 336, + 217, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 124, + 350 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 339, + 130, + 347 + ], + "score": 0.75, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 336, + 169, + 350 + ], + "score": 1.0, + "content": "-bound is", + "type": "text" + }, + { + "bbox": [ + 169, + 337, + 213, + 349 + ], + "score": 0.49, + "content": "[ - 1 . 5 , 1 . 5 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 336, + 217, + 350 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 107, + 473, + 505, + 628 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 473, + 505, + 628 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 473, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 107, + 473, + 505, + 628 + ], + "score": 0.854, + "type": "image", + "image_path": "c78f8a5fe014e2f444bb58892bc5fb5cb13c6cf56a7ada4884d05a07ae541f0a.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 107, + 473, + 505, + 524.6666666666666 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 524.6666666666666, + 505, + 576.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 576.3333333333333, + 505, + 627.9999999999999 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 636, + 504, + 670 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 486, + 649 + ], + "score": 1.0, + "content": "Figure 8: Plot showing the accuracy of various adversarially trained models on MNIST with", + "type": "text" + }, + { + "bbox": [ + 486, + 638, + 505, + 648 + ], + "score": 0.83, + "content": "\\varepsilon =", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 646, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 238, + 661 + ], + "score": 1.0, + "content": "0.3 (8a) and on CIFAR-10 with", + "type": "text" + }, + { + "bbox": [ + 238, + 648, + 283, + 658 + ], + "score": 0.88, + "content": "\\varepsilon = 0 . 0 3 1", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 646, + 473, + 661 + ], + "score": 1.0, + "content": "(8b), when attacked with increasing values of", + "type": "text" + }, + { + "bbox": [ + 473, + 650, + 479, + 658 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 646, + 506, + 661 + ], + "score": 1.0, + "content": "using", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 658, + 170, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 170, + 669 + ], + "score": 1.0, + "content": "PGD/LS-PGA.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 118, + 150, + 504, + 306 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 150, + 504, + 306 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 150, + 504, + 306 + ], + "spans": [ + { + "bbox": [ + 118, + 150, + 504, + 306 + ], + "score": 0.946, + "type": "image", + "image_path": "0604ba8d594b2cc20ab2cd825ddd95d7f109060c47f4da6bd6c0c716b6cb48a4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 150, + 504, + 202.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 202.0, + 504, + 254.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 254.0, + 504, + 306.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 315, + 506, + 349 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "Figure 7: Linear extrapolation plot as in Goodfellow et al. (2014) for MNIST. (7a) shows the behav-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 325, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 505, + 340 + ], + "score": 1.0, + "content": "ior of a vanilla model while (7b) for a discretized model using 16 levels and thermometer encoding.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 336, + 217, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 124, + 350 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 124, + 339, + 130, + 347 + ], + "score": 0.75, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 336, + 169, + 350 + ], + "score": 1.0, + "content": "-bound is", + "type": "text" + }, + { + "bbox": [ + 169, + 337, + 213, + 349 + ], + "score": 0.49, + "content": "[ - 1 . 5 , 1 . 5 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 336, + 217, + 350 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 107, + 473, + 505, + 628 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 473, + 505, + 628 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 473, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 107, + 473, + 505, + 628 + ], + "score": 0.854, + "type": "image", + "image_path": "c78f8a5fe014e2f444bb58892bc5fb5cb13c6cf56a7ada4884d05a07ae541f0a.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 107, + 473, + 505, + 524.6666666666666 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 107, + 524.6666666666666, + 505, + 576.3333333333333 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 107, + 576.3333333333333, + 505, + 627.9999999999999 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 636, + 504, + 670 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 486, + 649 + ], + "score": 1.0, + "content": "Figure 8: Plot showing the accuracy of various adversarially trained models on MNIST with", + "type": "text" + }, + { + "bbox": [ + 486, + 638, + 505, + 648 + ], + "score": 0.83, + "content": "\\varepsilon =", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 646, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 104, + 646, + 238, + 661 + ], + "score": 1.0, + "content": "0.3 (8a) and on CIFAR-10 with", + "type": "text" + }, + { + "bbox": [ + 238, + 648, + 283, + 658 + ], + "score": 0.88, + "content": "\\varepsilon = 0 . 0 3 1", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 646, + 473, + 661 + ], + "score": 1.0, + "content": "(8b), when attacked with increasing values of", + "type": "text" + }, + { + "bbox": [ + 473, + 650, + 479, + 658 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 646, + 506, + 661 + ], + "score": 1.0, + "content": "using", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 658, + 170, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 170, + 669 + ], + "score": 1.0, + "content": "PGD/LS-PGA.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "index": 8.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 151, + 503, + 581 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 151, + 503, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 151, + 503, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 503, + 581 + ], + "score": 0.978, + "type": "image", + "image_path": "d1f6655e799c3df8ee0c7d91633ddd42647398284e1ce47bb635c2f380feca43.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 151, + 503, + 294.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 294.33333333333337, + 503, + 437.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 437.66666666666674, + 503, + 581.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 407, + 599 + ], + "score": 1.0, + "content": "Figure 9: Church-window plots of clean-trained models on MNIST. The", + "type": "text" + }, + { + "bbox": [ + 408, + 590, + 415, + 597 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "-axis of each sub-plot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 290, + 611 + ], + "score": 1.0, + "content": "represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 290, + 600, + 297, + 610 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "correct class is represented by white. Every row in the plot contains a training data point chosen", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 475, + 633 + ], + "score": 1.0, + "content": "uniformly at random, while each column uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 475, + 623, + 482, + 632 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "-axis.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 125, + 644 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 633, + 132, + 641 + ], + "score": 0.69, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 631, + 231, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 232, + 631, + 275, + 644 + ], + "score": 0.76, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ". Notice the almost-linear decision boundaries on non-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "score": 1.0, + "content": "discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "17", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 151, + 503, + 581 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 151, + 503, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 151, + 503, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 503, + 581 + ], + "score": 0.978, + "type": "image", + "image_path": "d1f6655e799c3df8ee0c7d91633ddd42647398284e1ce47bb635c2f380feca43.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 151, + 503, + 294.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 294.33333333333337, + 503, + 437.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 437.66666666666674, + 503, + 581.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 407, + 599 + ], + "score": 1.0, + "content": "Figure 9: Church-window plots of clean-trained models on MNIST. The", + "type": "text" + }, + { + "bbox": [ + 408, + 590, + 415, + 597 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "-axis of each sub-plot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 290, + 611 + ], + "score": 1.0, + "content": "represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 290, + 600, + 297, + 610 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "correct class is represented by white. Every row in the plot contains a training data point chosen", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 475, + 633 + ], + "score": 1.0, + "content": "uniformly at random, while each column uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 475, + 623, + 482, + 632 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "-axis.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 125, + 644 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 633, + 132, + 641 + ], + "score": 0.69, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 631, + 231, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 232, + 631, + 275, + 644 + ], + "score": 0.76, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ". Notice the almost-linear decision boundaries on non-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "score": 1.0, + "content": "discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 159, + 503, + 586 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 159, + 503, + 586 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 159, + 503, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 503, + 586 + ], + "score": 0.974, + "type": "image", + "image_path": "a7c9b35d39f9aae5b0e758c5718f5e087620a70b03f03c951a8a59a7f1b044b2.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 159, + 503, + 301.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 301.33333333333337, + 503, + 443.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 443.66666666666674, + 503, + 586.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 505, + 649 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 593, + 504, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 593, + 504, + 605 + ], + "score": 1.0, + "content": "Figure 10: Church-window plots of adversarially-trained models on MNIST, trained on only adver-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 604, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 194, + 616 + ], + "score": 1.0, + "content": "sarial examples. The", + "type": "text" + }, + { + "bbox": [ + 194, + 606, + 201, + 614 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 604, + 477, + 616 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 478, + 606, + 484, + 616 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 604, + 505, + 616 + ], + "score": 1.0, + "content": "-axis", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "represents a random orthogonal direction. The correct class is represented by white. Every row", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "score": 1.0, + "content": "in the plot contains a training data point chosen uniformly at random, while each column uses a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 637, + 471, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 277, + 649 + ], + "score": 1.0, + "content": "different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 278, + 639, + 284, + 649 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 637, + 325, + 649 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 325, + 639, + 332, + 647 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 637, + 424, + 649 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 424, + 637, + 468, + 649 + ], + "score": 0.82, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 637, + 471, + 649 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + } + ], + "page_idx": 17, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 159, + 503, + 586 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 159, + 503, + 586 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 159, + 503, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 503, + 586 + ], + "score": 0.974, + "type": "image", + "image_path": "a7c9b35d39f9aae5b0e758c5718f5e087620a70b03f03c951a8a59a7f1b044b2.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 159, + 503, + 301.33333333333337 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 301.33333333333337, + 503, + 443.66666666666674 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 443.66666666666674, + 503, + 586.0000000000001 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 592, + 505, + 649 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 593, + 504, + 605 + ], + "spans": [ + { + "bbox": [ + 106, + 593, + 504, + 605 + ], + "score": 1.0, + "content": "Figure 10: Church-window plots of adversarially-trained models on MNIST, trained on only adver-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 604, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 194, + 616 + ], + "score": 1.0, + "content": "sarial examples. The", + "type": "text" + }, + { + "bbox": [ + 194, + 606, + 201, + 614 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 604, + 477, + 616 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 478, + 606, + 484, + 616 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 604, + 505, + 616 + ], + "score": 1.0, + "content": "-axis", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "represents a random orthogonal direction. The correct class is represented by white. Every row", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 506, + 638 + ], + "score": 1.0, + "content": "in the plot contains a training data point chosen uniformly at random, while each column uses a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 637, + 471, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 277, + 649 + ], + "score": 1.0, + "content": "different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 278, + 639, + 284, + 649 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 637, + 325, + 649 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 325, + 639, + 332, + 647 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 637, + 424, + 649 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 424, + 637, + 468, + 649 + ], + "score": 0.82, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 637, + 471, + 649 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 153, + 503, + 582 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 153, + 503, + 582 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 153, + 503, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 503, + 582 + ], + "score": 0.975, + "type": "image", + "image_path": "f110fa7dc03c228647aad430e7c23c0aa9d8f9045ebe745e79b586287148d078.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 153, + 503, + 296.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 296.0, + 503, + 439.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 439.0, + 503, + 582.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Figure 11: Church-window plots of adversarially-trained models on MNIST, trained using a mix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 266, + 611 + ], + "score": 1.0, + "content": "of clean and adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 266, + 600, + 273, + 609 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 145, + 622 + ], + "score": 1.0, + "content": "while the", + "type": "text" + }, + { + "bbox": [ + 145, + 611, + 152, + 621 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Every row in the plot contains a training data point chosen uniformly at random, while each column", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 307, + 644 + ], + "score": 1.0, + "content": "uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 307, + 633, + 313, + 643 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 631, + 356, + 644 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 356, + 633, + 363, + 641 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 631, + 457, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 457, + 631, + 501, + 644 + ], + "score": 0.74, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 397, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 397, + 654 + ], + "score": 1.0, + "content": "Notice the almost-linear decision boundaries on non-discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ], + "page_idx": 18, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "19", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 153, + 503, + 582 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 153, + 503, + 582 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 153, + 503, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 503, + 582 + ], + "score": 0.975, + "type": "image", + "image_path": "f110fa7dc03c228647aad430e7c23c0aa9d8f9045ebe745e79b586287148d078.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 153, + 503, + 296.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 296.0, + 503, + 439.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 439.0, + 503, + 582.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Figure 11: Church-window plots of adversarially-trained models on MNIST, trained using a mix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 266, + 611 + ], + "score": 1.0, + "content": "of clean and adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 266, + 600, + 273, + 609 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 145, + 622 + ], + "score": 1.0, + "content": "while the", + "type": "text" + }, + { + "bbox": [ + 145, + 611, + 152, + 621 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Every row in the plot contains a training data point chosen uniformly at random, while each column", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 307, + 644 + ], + "score": 1.0, + "content": "uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 307, + 633, + 313, + 643 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 631, + 356, + 644 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 356, + 633, + 363, + 641 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 631, + 457, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 457, + 631, + 501, + 644 + ], + "score": 0.74, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 397, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 397, + 654 + ], + "score": 1.0, + "content": "Notice the almost-linear decision boundaries on non-discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 150, + 503, + 581 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 150, + 503, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 150, + 503, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 503, + 581 + ], + "score": 0.978, + "type": "image", + "image_path": "de62ebb60756bab3e9b9f0d3e2a7a522816c61a5478d63537904a6753e8ba708.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 150, + 503, + 293.66666666666663 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 293.66666666666663, + 503, + 437.33333333333326 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 437.33333333333326, + 503, + 580.9999999999999 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 411, + 599 + ], + "score": 1.0, + "content": "Figure 12: Church-window plots of clean-trained models on CIFAR-10. The", + "type": "text" + }, + { + "bbox": [ + 412, + 590, + 419, + 598 + ], + "score": 0.81, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "-axis of each sub-plot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 290, + 611 + ], + "score": 1.0, + "content": "represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 290, + 600, + 297, + 610 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "correct class is represented by white. Every row in the plot contains a training data point chosen", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 475, + 633 + ], + "score": 1.0, + "content": "uniformly at random, while each column uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 475, + 623, + 482, + 632 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "-axis.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 125, + 644 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 633, + 132, + 642 + ], + "score": 0.7, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 631, + 231, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 232, + 631, + 275, + 644 + ], + "score": 0.78, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ". Notice the almost-linear decision boundaries on non-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "score": 1.0, + "content": "discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ], + "page_idx": 19, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 749, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 749, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 150, + 503, + 581 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 150, + 503, + 581 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 150, + 503, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 503, + 581 + ], + "score": 0.978, + "type": "image", + "image_path": "de62ebb60756bab3e9b9f0d3e2a7a522816c61a5478d63537904a6753e8ba708.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 150, + 503, + 293.66666666666663 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 293.66666666666663, + 503, + 437.33333333333326 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 437.33333333333326, + 503, + 580.9999999999999 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 411, + 599 + ], + "score": 1.0, + "content": "Figure 12: Church-window plots of clean-trained models on CIFAR-10. The", + "type": "text" + }, + { + "bbox": [ + 412, + 590, + 419, + 598 + ], + "score": 0.81, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "-axis of each sub-plot", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 599, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 290, + 611 + ], + "score": 1.0, + "content": "represents the adversarial direction, while the", + "type": "text" + }, + { + "bbox": [ + 290, + 600, + 297, + 610 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 599, + 505, + 611 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "correct class is represented by white. Every row in the plot contains a training data point chosen", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 620, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 475, + 633 + ], + "score": 1.0, + "content": "uniformly at random, while each column uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 475, + 623, + 482, + 632 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 620, + 505, + 633 + ], + "score": 1.0, + "content": "-axis.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 125, + 644 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 125, + 633, + 132, + 642 + ], + "score": 0.7, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 631, + 231, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 232, + 631, + 275, + 644 + ], + "score": 0.78, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ". Notice the almost-linear decision boundaries on non-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 186, + 654 + ], + "score": 1.0, + "content": "discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 76, + 503, + 506 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 76, + 503, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 76, + 503, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 76, + 503, + 506 + ], + "score": 0.977, + "type": "image", + "image_path": "533fb3c9d3296390750f7f7c0d5de121e121313c39a27778531efd51f4a48fb9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 76, + 503, + 219.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 219.33333333333334, + 503, + 362.6666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 362.6666666666667, + 503, + 506.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 512, + 506, + 568 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "Figure 13: Church-window plots of adversarially-trained models on CIFAR-10, trained on only", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 218, + 536 + ], + "score": 1.0, + "content": "adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 218, + 525, + 225, + 534 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 524, + 505, + 536 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction, while the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 113, + 546 + ], + "score": 0.77, + "content": "y \\cdot", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white. Every", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "score": 1.0, + "content": "row in the plot contains a training data point chosen uniformly at random, while each column uses a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 556, + 472, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 277, + 570 + ], + "score": 1.0, + "content": "different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 278, + 559, + 284, + 568 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 556, + 325, + 570 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 326, + 558, + 332, + 567 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 556, + 424, + 570 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 424, + 556, + 468, + 569 + ], + "score": 0.79, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 556, + 472, + 570 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + } + ], + "page_idx": 20, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 76, + 503, + 506 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 76, + 503, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 76, + 503, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 76, + 503, + 506 + ], + "score": 0.977, + "type": "image", + "image_path": "533fb3c9d3296390750f7f7c0d5de121e121313c39a27778531efd51f4a48fb9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 76, + 503, + 219.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 219.33333333333334, + 503, + 362.6666666666667 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 362.6666666666667, + 503, + 506.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 512, + 506, + 568 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "Figure 13: Church-window plots of adversarially-trained models on CIFAR-10, trained on only", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 218, + 536 + ], + "score": 1.0, + "content": "adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 218, + 525, + 225, + 534 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 524, + 505, + 536 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction, while the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 113, + 546 + ], + "score": 0.77, + "content": "y \\cdot", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white. Every", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 506, + 559 + ], + "score": 1.0, + "content": "row in the plot contains a training data point chosen uniformly at random, while each column uses a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 556, + 472, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 277, + 570 + ], + "score": 1.0, + "content": "different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 278, + 559, + 284, + 568 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 556, + 325, + 570 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 326, + 558, + 332, + 567 + ], + "score": 0.76, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 556, + 424, + 570 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 424, + 556, + 468, + 569 + ], + "score": 0.79, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 556, + 472, + 570 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 150, + 503, + 582 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 150, + 503, + 582 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 150, + 503, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 503, + 582 + ], + "score": 0.976, + "type": "image", + "image_path": "a379953bd90bdb3939721bdba8051da89b967e596d108733d52c8302e4f8dc62.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 150, + 503, + 294.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 294.0, + 503, + 438.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 438.0, + 503, + 582.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Figure 14: Church-window plots of adversarially-trained models on CIFAR-10, trained using a mix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 265, + 611 + ], + "score": 1.0, + "content": "of clean and adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 266, + 600, + 273, + 609 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 145, + 622 + ], + "score": 1.0, + "content": "while the", + "type": "text" + }, + { + "bbox": [ + 145, + 611, + 152, + 621 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Every row in the plot contains a training data point chosen uniformly at random, while each column", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 307, + 644 + ], + "score": 1.0, + "content": "uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 307, + 633, + 313, + 643 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 631, + 356, + 644 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 356, + 633, + 363, + 641 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 631, + 457, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 457, + 631, + 501, + 644 + ], + "score": 0.72, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 396, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 396, + 653 + ], + "score": 1.0, + "content": "Notice the almost-linear decision boundaries on non-discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ], + "page_idx": 21, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 150, + 503, + 582 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 150, + 503, + 582 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 150, + 503, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 150, + 503, + 582 + ], + "score": 0.976, + "type": "image", + "image_path": "a379953bd90bdb3939721bdba8051da89b967e596d108733d52c8302e4f8dc62.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 150, + 503, + 294.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 294.0, + 503, + 438.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 438.0, + 503, + 582.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 587, + 505, + 654 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Figure 14: Church-window plots of adversarially-trained models on CIFAR-10, trained using a mix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 265, + 611 + ], + "score": 1.0, + "content": "of clean and adversarial examples. The", + "type": "text" + }, + { + "bbox": [ + 266, + 600, + 273, + 609 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "-axis of each sub-plot represents the adversarial direction,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 145, + 622 + ], + "score": 1.0, + "content": "while the", + "type": "text" + }, + { + "bbox": [ + 145, + 611, + 152, + 621 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "-axis represents a random orthogonal direction. The correct class is represented by white.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Every row in the plot contains a training data point chosen uniformly at random, while each column", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 307, + 644 + ], + "score": 1.0, + "content": "uses a different random orthogonal vector for the", + "type": "text" + }, + { + "bbox": [ + 307, + 633, + 313, + 643 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 631, + 356, + 644 + ], + "score": 1.0, + "content": "-axis. The", + "type": "text" + }, + { + "bbox": [ + 356, + 633, + 363, + 641 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 631, + 457, + 644 + ], + "score": 1.0, + "content": "bound for both axes is", + "type": "text" + }, + { + "bbox": [ + 457, + 631, + 501, + 644 + ], + "score": 0.72, + "content": "[ - 1 . 0 , 1 . 0 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 642, + 396, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 396, + 653 + ], + "score": 1.0, + "content": "Notice the almost-linear decision boundaries on non-discretized models.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file