diff --git "a/parse/train/NiM9Q7Z95z/NiM9Q7Z95z_middle.json" "b/parse/train/NiM9Q7Z95z/NiM9Q7Z95z_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/NiM9Q7Z95z/NiM9Q7Z95z_middle.json" @@ -0,0 +1,38691 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 134, + 97, + 477, + 118 + ], + "lines": [ + { + "bbox": [ + 133, + 94, + 478, + 122 + ], + "spans": [ + { + "bbox": [ + 133, + 94, + 478, + 122 + ], + "score": 1.0, + "content": "Secure Quantized Training for Deep Learning", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 259, + 159, + 355, + 203 + ], + "lines": [ + { + "bbox": [ + 258, + 159, + 356, + 171 + ], + "spans": [ + { + "bbox": [ + 258, + 159, + 356, + 171 + ], + "score": 1.0, + "content": "Anonymous Author(s)", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 283, + 169, + 328, + 182 + ], + "spans": [ + { + "bbox": [ + 283, + 169, + 328, + 182 + ], + "score": 1.0, + "content": "Affiliation", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 287, + 180, + 324, + 193 + ], + "spans": [ + { + "bbox": [ + 287, + 180, + 324, + 193 + ], + "score": 1.0, + "content": "Address", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 290, + 193, + 320, + 203 + ], + "spans": [ + { + "bbox": [ + 290, + 193, + 320, + 203 + ], + "score": 1.0, + "content": "email", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 283, + 232, + 328, + 245 + ], + "lines": [ + { + "bbox": [ + 281, + 231, + 331, + 246 + ], + "spans": [ + { + "bbox": [ + 281, + 231, + 331, + 246 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 92, + 255, + 470, + 344 + ], + "lines": [ + { + "bbox": [ + 93, + 255, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 93, + 259, + 99, + 267 + ], + "score": 1.0, + "content": "1", + "type": "text" + }, + { + "bbox": [ + 142, + 255, + 470, + 269 + ], + "score": 1.0, + "content": "We have implemented training of neural networks in secure multi-party computa-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 93, + 267, + 470, + 280 + ], + "spans": [ + { + "bbox": [ + 93, + 270, + 99, + 277 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 142, + 267, + 470, + 280 + ], + "score": 1.0, + "content": "tion (MPC) using quantization commonly used in said setting. To the best of our", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 93, + 278, + 469, + 290 + ], + "spans": [ + { + "bbox": [ + 93, + 281, + 99, + 289 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 142, + 278, + 469, + 290 + ], + "score": 1.0, + "content": "knowledge, we are the first to present training of MNIST purely implemented in", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 93, + 289, + 470, + 302 + ], + "spans": [ + { + "bbox": [ + 93, + 291, + 100, + 300 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 141, + 289, + 470, + 302 + ], + "score": 1.0, + "content": "MPC that comes within one percent of accuracy of training using plaintext compu-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 93, + 300, + 470, + 312 + ], + "spans": [ + { + "bbox": [ + 93, + 302, + 100, + 311 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 142, + 300, + 470, + 312 + ], + "score": 1.0, + "content": "tation. We found that training with MPC is possible, but it takes more epochs and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 93, + 309, + 470, + 324 + ], + "spans": [ + { + "bbox": [ + 93, + 313, + 100, + 322 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 141, + 309, + 470, + 324 + ], + "score": 1.0, + "content": "achieves a lower accuracy than the usual CPU/GPU computation. More concretely,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 93, + 322, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 93, + 324, + 99, + 333 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 142, + 322, + 441, + 334 + ], + "score": 1.0, + "content": "we have trained a network with two convolution and two dense layers to", + "type": "text" + }, + { + "bbox": [ + 441, + 322, + 469, + 332 + ], + "score": 0.84, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 93, + 332, + 423, + 345 + ], + "spans": [ + { + "bbox": [ + 93, + 335, + 100, + 343 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 141, + 332, + 423, + 345 + ], + "score": 1.0, + "content": "accuracy in 150 epochs. This took a day in our MPC implementation.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 93, + 363, + 191, + 376 + ], + "lines": [ + { + "bbox": [ + 90, + 362, + 192, + 379 + ], + "spans": [ + { + "bbox": [ + 90, + 362, + 192, + 379 + ], + "score": 1.0, + "content": "9 1 Introduction", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 91, + 387, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 90, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 90, + 389, + 100, + 399 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "Secure multi-party computation (MPC) is a cryptographic technique that allows a set of parties to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 90, + 398, + 507, + 411 + ], + "spans": [ + { + "bbox": [ + 90, + 401, + 99, + 409 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 105, + 398, + 507, + 411 + ], + "score": 1.0, + "content": "compute a public output on private inputs without revealing the inputs or any intermediate results.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 90, + 409, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 90, + 411, + 100, + 421 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "score": 1.0, + "content": "This makes it a potential solution to federated learning where the sample data stays private and only", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 90, + 420, + 321, + 433 + ], + "spans": [ + { + "bbox": [ + 90, + 422, + 100, + 432 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 105, + 420, + 321, + 433 + ], + "score": 1.0, + "content": "the model or even only inference results are revealed.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 91, + 436, + 505, + 491 + ], + "lines": [ + { + "bbox": [ + 90, + 437, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 90, + 439, + 99, + 447 + ], + "score": 1.0, + "content": "14", + "type": "text" + }, + { + "bbox": [ + 106, + 437, + 506, + 448 + ], + "score": 1.0, + "content": "Imagine a set of healthcare providers holding sensitive patient data. MPC allows them to collabo-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 90, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 90, + 450, + 99, + 460 + ], + "score": 1.0, + "content": "15", + "type": "text" + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "ratively train a model. This model could then either be released or even kept private for inference", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 90, + 458, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 90, + 461, + 100, + 470 + ], + "score": 1.0, + "content": "16", + "type": "text" + }, + { + "bbox": [ + 105, + 458, + 506, + 471 + ], + "score": 1.0, + "content": "using MPC again. See Figure for an illustration. A more conceptual example is the well-known", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 90, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 90, + 471, + 100, + 481 + ], + "score": 1.0, + "content": "17", + "type": "text" + }, + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "millionaires’ problem where two people want to find out who is richer without revealing their wealth.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 90, + 480, + 471, + 493 + ], + "spans": [ + { + "bbox": [ + 90, + 483, + 100, + 492 + ], + "score": 1.0, + "content": "18", + "type": "text" + }, + { + "bbox": [ + 105, + 480, + 471, + 493 + ], + "score": 1.0, + "content": "There is clearly a difference between the one bit of information desired and the full figures.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 91, + 496, + 504, + 530 + ], + "lines": [ + { + "bbox": [ + 91, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 91, + 499, + 100, + 507 + ], + "score": 1.0, + "content": "19", + "type": "text" + }, + { + "bbox": [ + 103, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "There has been a sustained interest in applying secure computation to machine learning and neural", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 90, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 90, + 510, + 100, + 518 + ], + "score": 1.0, + "content": "20", + "type": "text" + }, + { + "bbox": [ + 103, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "networks going back to at least Barni et al. [2006]. More recent advantages in practical MPC have", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 90, + 517, + 389, + 532 + ], + "spans": [ + { + "bbox": [ + 90, + 521, + 100, + 529 + ], + "score": 1.0, + "content": "21", + "type": "text" + }, + { + "bbox": [ + 103, + 517, + 389, + 532 + ], + "score": 1.0, + "content": "led to an increased effort in implementing both inference and training.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 90, + 534, + 506, + 677 + ], + "lines": [ + { + "bbox": [ + 89, + 534, + 507, + 547 + ], + "spans": [ + { + "bbox": [ + 89, + 536, + 99, + 546 + ], + "score": 1.0, + "content": "22", + "type": "text" + }, + { + "bbox": [ + 105, + 534, + 507, + 547 + ], + "score": 1.0, + "content": "A number of works such as Mohassel and Zhang [2017], Mohassel and Rindal [2018], Wagh et al.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 89, + 545, + 507, + 560 + ], + "spans": [ + { + "bbox": [ + 89, + 547, + 99, + 558 + ], + "score": 1.0, + "content": "23", + "type": "text" + }, + { + "bbox": [ + 105, + 545, + 507, + 560 + ], + "score": 1.0, + "content": "[2019], Wagh et al. [2021] implement neural network training with MPC at least in parts. However,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 89, + 555, + 507, + 571 + ], + "spans": [ + { + "bbox": [ + 89, + 559, + 99, + 568 + ], + "score": 1.0, + "content": "24", + "type": "text" + }, + { + "bbox": [ + 104, + 555, + 259, + 571 + ], + "score": 1.0, + "content": "they either give accuracy figures below", + "type": "text" + }, + { + "bbox": [ + 259, + 557, + 279, + 567 + ], + "score": 0.88, + "content": "9 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 555, + 507, + 571 + ], + "score": 1.0, + "content": "or figures that have been obtained using plaintext training.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 89, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 89, + 569, + 100, + 579 + ], + "score": 1.0, + "content": "25", + "type": "text" + }, + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "For the latter case, the works do not clarify how close the computation for plaintext training matches", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 88, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 88, + 581, + 99, + 590 + ], + "score": 1.0, + "content": "26", + "type": "text" + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "the lower precision and other differences in the MPC setting. Agrawal et al. [2019] claim a higher", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 89, + 589, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 89, + 592, + 100, + 601 + ], + "score": 1.0, + "content": "27", + "type": "text" + }, + { + "bbox": [ + 105, + 589, + 506, + 602 + ], + "score": 1.0, + "content": "accuracy in a comparable setting for a convolutional neural network with more channels than we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 88, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 88, + 603, + 99, + 612 + ], + "score": 1.0, + "content": "28", + "type": "text" + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "use. However, they have only implemented dense layers, and we achieve comparable accuracy to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 89, + 612, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 89, + 613, + 100, + 623 + ], + "score": 1.0, + "content": "29", + "type": "text" + }, + { + "bbox": [ + 106, + 612, + 487, + 623 + ], + "score": 1.0, + "content": "them with only dense layers. All works use quantization in the sense that a fractional number", + "type": "text" + }, + { + "bbox": [ + 487, + 613, + 495, + 621 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 612, + 506, + 623 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 89, + 621, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 89, + 624, + 100, + 634 + ], + "score": 1.0, + "content": "30", + "type": "text" + }, + { + "bbox": [ + 104, + 621, + 166, + 636 + ], + "score": 1.0, + "content": "represented as", + "type": "text" + }, + { + "bbox": [ + 167, + 622, + 205, + 634 + ], + "score": 0.93, + "content": "\\lfloor x \\cdot 2 ^ { - f } \\rceil", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 621, + 506, + 636 + ], + "score": 1.0, + "content": ". This makes addition considerably faster in the secure computation setting", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 88, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 88, + 635, + 99, + 645 + ], + "score": 1.0, + "content": "31", + "type": "text" + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "because it reduces to integer addition. Furthermore, some of the works suggest to replace the softmax", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 89, + 644, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 89, + 646, + 100, + 656 + ], + "score": 1.0, + "content": "32", + "type": "text" + }, + { + "bbox": [ + 105, + 644, + 506, + 656 + ], + "score": 1.0, + "content": "function that uses exponentiation with a ReLU-based replacement. Keller and Sun [2020] have found", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 89, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 89, + 657, + 100, + 666 + ], + "score": 1.0, + "content": "33", + "type": "text" + }, + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "that this softmax replacement deteriorates accuracy in dense neural networks to the extent that it does", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 89, + 666, + 243, + 678 + ], + "spans": [ + { + "bbox": [ + 89, + 668, + 100, + 677 + ], + "score": 1.0, + "content": "34", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 243, + 678 + ], + "score": 1.0, + "content": "not justify the performance gains.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 91, + 681, + 504, + 715 + ], + "lines": [ + { + "bbox": [ + 89, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 89, + 684, + 99, + 693 + ], + "score": 1.0, + "content": "35", + "type": "text" + }, + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "The concurrent work of Tan et al. [2021] gives some figures on the learning curve when run using", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 90, + 693, + 505, + 705 + ], + "spans": [ + { + "bbox": [ + 90, + 696, + 99, + 704 + ], + "score": 1.0, + "content": "36", + "type": "text" + }, + { + "bbox": [ + 104, + 693, + 484, + 705 + ], + "score": 1.0, + "content": "secure computation. However, they stop at five epochs for MNIST training where they achieve", + "type": "text" + }, + { + "bbox": [ + 485, + 693, + 505, + 704 + ], + "score": 0.85, + "content": "94 \\%", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 90, + 704, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 90, + 707, + 100, + 716 + ], + "score": 1.0, + "content": "37", + "type": "text" + }, + { + "bbox": [ + 105, + 704, + 359, + 716 + ], + "score": 1.0, + "content": "accuracy whereas we present the figures up to 150 epochs and", + "type": "text" + }, + { + "bbox": [ + 359, + 704, + 387, + 714 + ], + "score": 0.84, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 704, + 505, + 716 + ], + "score": 1.0, + "content": "accuracy. Furthermore, their", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 102, + 731, + 499, + 742 + ], + "lines": [ + { + "bbox": [ + 106, + 730, + 500, + 743 + ], + "spans": [ + { + "bbox": [ + 106, + 730, + 500, + 743 + ], + "score": 1.0, + "content": "Submitted to 35th Conference on Neural Information Processing Systems (NeurIPS 2021). Do not distribute.", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 134, + 97, + 477, + 118 + ], + "lines": [ + { + "bbox": [ + 133, + 94, + 478, + 122 + ], + "spans": [ + { + "bbox": [ + 133, + 94, + 478, + 122 + ], + "score": 1.0, + "content": "Secure Quantized Training for Deep Learning", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "list", + "bbox": [ + 259, + 159, + 355, + 203 + ], + "lines": [ + { + "bbox": [ + 258, + 159, + 356, + 171 + ], + "spans": [ + { + "bbox": [ + 258, + 159, + 356, + 171 + ], + "score": 1.0, + "content": "Anonymous Author(s)", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 283, + 169, + 328, + 182 + ], + "spans": [ + { + "bbox": [ + 283, + 169, + 328, + 182 + ], + "score": 1.0, + "content": "Affiliation", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 287, + 180, + 324, + 193 + ], + "spans": [ + { + "bbox": [ + 287, + 180, + 324, + 193 + ], + "score": 1.0, + "content": "Address", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 290, + 193, + 320, + 203 + ], + "spans": [ + { + "bbox": [ + 290, + 193, + 320, + 203 + ], + "score": 1.0, + "content": "email", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + } + ], + "index": 2.5, + "bbox_fs": [ + 258, + 159, + 356, + 203 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 232, + 328, + 245 + ], + "lines": [ + { + "bbox": [ + 281, + 231, + 331, + 246 + ], + "spans": [ + { + "bbox": [ + 281, + 231, + 331, + 246 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "index", + "bbox": [ + 92, + 255, + 470, + 344 + ], + "lines": [ + { + "bbox": [ + 93, + 255, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 93, + 259, + 99, + 267 + ], + "score": 1.0, + "content": "1", + "type": "text" + }, + { + "bbox": [ + 142, + 255, + 470, + 269 + ], + "score": 1.0, + "content": "We have implemented training of neural networks in secure multi-party computa-", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 267, + 470, + 280 + ], + "spans": [ + { + "bbox": [ + 93, + 270, + 99, + 277 + ], + "score": 1.0, + "content": "2", + "type": "text" + }, + { + "bbox": [ + 142, + 267, + 470, + 280 + ], + "score": 1.0, + "content": "tion (MPC) using quantization commonly used in said setting. To the best of our", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 278, + 469, + 290 + ], + "spans": [ + { + "bbox": [ + 93, + 281, + 99, + 289 + ], + "score": 1.0, + "content": "3", + "type": "text" + }, + { + "bbox": [ + 142, + 278, + 469, + 290 + ], + "score": 1.0, + "content": "knowledge, we are the first to present training of MNIST purely implemented in", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 289, + 470, + 302 + ], + "spans": [ + { + "bbox": [ + 93, + 291, + 100, + 300 + ], + "score": 1.0, + "content": "4", + "type": "text" + }, + { + "bbox": [ + 141, + 289, + 470, + 302 + ], + "score": 1.0, + "content": "MPC that comes within one percent of accuracy of training using plaintext compu-", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 300, + 470, + 312 + ], + "spans": [ + { + "bbox": [ + 93, + 302, + 100, + 311 + ], + "score": 1.0, + "content": "5", + "type": "text" + }, + { + "bbox": [ + 142, + 300, + 470, + 312 + ], + "score": 1.0, + "content": "tation. We found that training with MPC is possible, but it takes more epochs and", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 309, + 470, + 324 + ], + "spans": [ + { + "bbox": [ + 93, + 313, + 100, + 322 + ], + "score": 1.0, + "content": "6", + "type": "text" + }, + { + "bbox": [ + 141, + 309, + 470, + 324 + ], + "score": 1.0, + "content": "achieves a lower accuracy than the usual CPU/GPU computation. More concretely,", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 322, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 93, + 324, + 99, + 333 + ], + "score": 1.0, + "content": "7", + "type": "text" + }, + { + "bbox": [ + 142, + 322, + 441, + 334 + ], + "score": 1.0, + "content": "we have trained a network with two convolution and two dense layers to", + "type": "text" + }, + { + "bbox": [ + 441, + 322, + 469, + 332 + ], + "score": 0.84, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 93, + 332, + 423, + 345 + ], + "spans": [ + { + "bbox": [ + 93, + 335, + 100, + 343 + ], + "score": 1.0, + "content": "8", + "type": "text" + }, + { + "bbox": [ + 141, + 332, + 423, + 345 + ], + "score": 1.0, + "content": "accuracy in 150 epochs. This took a day in our MPC implementation.", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + } + ], + "index": 9.5, + "bbox_fs": [ + 93, + 255, + 470, + 345 + ] + }, + { + "type": "title", + "bbox": [ + 93, + 363, + 191, + 376 + ], + "lines": [ + { + "bbox": [ + 90, + 362, + 192, + 379 + ], + "spans": [ + { + "bbox": [ + 90, + 362, + 192, + 379 + ], + "score": 1.0, + "content": "9 1 Introduction", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "index", + "bbox": [ + 91, + 387, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 90, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 90, + 389, + 100, + 399 + ], + "score": 1.0, + "content": "10", + "type": "text" + }, + { + "bbox": [ + 106, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "Secure multi-party computation (MPC) is a cryptographic technique that allows a set of parties to", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 398, + 507, + 411 + ], + "spans": [ + { + "bbox": [ + 90, + 401, + 99, + 409 + ], + "score": 1.0, + "content": "11", + "type": "text" + }, + { + "bbox": [ + 105, + 398, + 507, + 411 + ], + "score": 1.0, + "content": "compute a public output on private inputs without revealing the inputs or any intermediate results.", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 409, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 90, + 411, + 100, + 421 + ], + "score": 1.0, + "content": "12", + "type": "text" + }, + { + "bbox": [ + 105, + 409, + 505, + 422 + ], + "score": 1.0, + "content": "This makes it a potential solution to federated learning where the sample data stays private and only", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 420, + 321, + 433 + ], + "spans": [ + { + "bbox": [ + 90, + 422, + 100, + 432 + ], + "score": 1.0, + "content": "13", + "type": "text" + }, + { + "bbox": [ + 105, + 420, + 321, + 433 + ], + "score": 1.0, + "content": "the model or even only inference results are revealed.", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 437, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 90, + 439, + 99, + 447 + ], + "score": 1.0, + "content": "14", + "type": "text" + }, + { + "bbox": [ + 106, + 437, + 506, + 448 + ], + "score": 1.0, + "content": "Imagine a set of healthcare providers holding sensitive patient data. MPC allows them to collabo-", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 90, + 450, + 99, + 460 + ], + "score": 1.0, + "content": "15", + "type": "text" + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "ratively train a model. This model could then either be released or even kept private for inference", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 458, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 90, + 461, + 100, + 470 + ], + "score": 1.0, + "content": "16", + "type": "text" + }, + { + "bbox": [ + 105, + 458, + 506, + 471 + ], + "score": 1.0, + "content": "using MPC again. See Figure for an illustration. A more conceptual example is the well-known", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 90, + 471, + 100, + 481 + ], + "score": 1.0, + "content": "17", + "type": "text" + }, + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "millionaires’ problem where two people want to find out who is richer without revealing their wealth.", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 480, + 471, + 493 + ], + "spans": [ + { + "bbox": [ + 90, + 483, + 100, + 492 + ], + "score": 1.0, + "content": "18", + "type": "text" + }, + { + "bbox": [ + 105, + 480, + 471, + 493 + ], + "score": 1.0, + "content": "There is clearly a difference between the one bit of information desired and the full figures.", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 91, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 91, + 499, + 100, + 507 + ], + "score": 1.0, + "content": "19", + "type": "text" + }, + { + "bbox": [ + 103, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "There has been a sustained interest in applying secure computation to machine learning and neural", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 90, + 510, + 100, + 518 + ], + "score": 1.0, + "content": "20", + "type": "text" + }, + { + "bbox": [ + 103, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "networks going back to at least Barni et al. [2006]. More recent advantages in practical MPC have", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 517, + 389, + 532 + ], + "spans": [ + { + "bbox": [ + 90, + 521, + 100, + 529 + ], + "score": 1.0, + "content": "21", + "type": "text" + }, + { + "bbox": [ + 103, + 517, + 389, + 532 + ], + "score": 1.0, + "content": "led to an increased effort in implementing both inference and training.", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 534, + 507, + 547 + ], + "spans": [ + { + "bbox": [ + 89, + 536, + 99, + 546 + ], + "score": 1.0, + "content": "22", + "type": "text" + }, + { + "bbox": [ + 105, + 534, + 507, + 547 + ], + "score": 1.0, + "content": "A number of works such as Mohassel and Zhang [2017], Mohassel and Rindal [2018], Wagh et al.", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 545, + 507, + 560 + ], + "spans": [ + { + "bbox": [ + 89, + 547, + 99, + 558 + ], + "score": 1.0, + "content": "23", + "type": "text" + }, + { + "bbox": [ + 105, + 545, + 507, + 560 + ], + "score": 1.0, + "content": "[2019], Wagh et al. [2021] implement neural network training with MPC at least in parts. However,", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 555, + 507, + 571 + ], + "spans": [ + { + "bbox": [ + 89, + 559, + 99, + 568 + ], + "score": 1.0, + "content": "24", + "type": "text" + }, + { + "bbox": [ + 104, + 555, + 259, + 571 + ], + "score": 1.0, + "content": "they either give accuracy figures below", + "type": "text" + }, + { + "bbox": [ + 259, + 557, + 279, + 567 + ], + "score": 0.88, + "content": "9 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 555, + 507, + 571 + ], + "score": 1.0, + "content": "or figures that have been obtained using plaintext training.", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 89, + 569, + 100, + 579 + ], + "score": 1.0, + "content": "25", + "type": "text" + }, + { + "bbox": [ + 105, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "For the latter case, the works do not clarify how close the computation for plaintext training matches", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 88, + 581, + 99, + 590 + ], + "score": 1.0, + "content": "26", + "type": "text" + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "the lower precision and other differences in the MPC setting. Agrawal et al. [2019] claim a higher", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 589, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 89, + 592, + 100, + 601 + ], + "score": 1.0, + "content": "27", + "type": "text" + }, + { + "bbox": [ + 105, + 589, + 506, + 602 + ], + "score": 1.0, + "content": "accuracy in a comparable setting for a convolutional neural network with more channels than we", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 88, + 603, + 99, + 612 + ], + "score": 1.0, + "content": "28", + "type": "text" + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "use. However, they have only implemented dense layers, and we achieve comparable accuracy to", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 612, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 89, + 613, + 100, + 623 + ], + "score": 1.0, + "content": "29", + "type": "text" + }, + { + "bbox": [ + 106, + 612, + 487, + 623 + ], + "score": 1.0, + "content": "them with only dense layers. All works use quantization in the sense that a fractional number", + "type": "text" + }, + { + "bbox": [ + 487, + 613, + 495, + 621 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 612, + 506, + 623 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 621, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 89, + 624, + 100, + 634 + ], + "score": 1.0, + "content": "30", + "type": "text" + }, + { + "bbox": [ + 104, + 621, + 166, + 636 + ], + "score": 1.0, + "content": "represented as", + "type": "text" + }, + { + "bbox": [ + 167, + 622, + 205, + 634 + ], + "score": 0.93, + "content": "\\lfloor x \\cdot 2 ^ { - f } \\rceil", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 621, + 506, + 636 + ], + "score": 1.0, + "content": ". This makes addition considerably faster in the secure computation setting", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 88, + 635, + 99, + 645 + ], + "score": 1.0, + "content": "31", + "type": "text" + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "because it reduces to integer addition. Furthermore, some of the works suggest to replace the softmax", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 644, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 89, + 646, + 100, + 656 + ], + "score": 1.0, + "content": "32", + "type": "text" + }, + { + "bbox": [ + 105, + 644, + 506, + 656 + ], + "score": 1.0, + "content": "function that uses exponentiation with a ReLU-based replacement. Keller and Sun [2020] have found", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 89, + 657, + 100, + 666 + ], + "score": 1.0, + "content": "33", + "type": "text" + }, + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "that this softmax replacement deteriorates accuracy in dense neural networks to the extent that it does", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 666, + 243, + 678 + ], + "spans": [ + { + "bbox": [ + 89, + 668, + 100, + 677 + ], + "score": 1.0, + "content": "34", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 243, + 678 + ], + "score": 1.0, + "content": "not justify the performance gains.", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 681, + 505, + 695 + ], + "spans": [ + { + "bbox": [ + 89, + 684, + 99, + 693 + ], + "score": 1.0, + "content": "35", + "type": "text" + }, + { + "bbox": [ + 105, + 681, + 505, + 695 + ], + "score": 1.0, + "content": "The concurrent work of Tan et al. [2021] gives some figures on the learning curve when run using", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 693, + 505, + 705 + ], + "spans": [ + { + "bbox": [ + 90, + 696, + 99, + 704 + ], + "score": 1.0, + "content": "36", + "type": "text" + }, + { + "bbox": [ + 104, + 693, + 484, + 705 + ], + "score": 1.0, + "content": "secure computation. However, they stop at five epochs for MNIST training where they achieve", + "type": "text" + }, + { + "bbox": [ + 485, + 693, + 505, + 704 + ], + "score": 0.85, + "content": "94 \\%", + "type": "inline_equation" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 704, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 90, + 707, + 100, + 716 + ], + "score": 1.0, + "content": "37", + "type": "text" + }, + { + "bbox": [ + 105, + 704, + 359, + 716 + ], + "score": 1.0, + "content": "accuracy whereas we present the figures up to 150 epochs and", + "type": "text" + }, + { + "bbox": [ + 359, + 704, + 387, + 714 + ], + "score": 0.84, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 704, + 505, + 716 + ], + "score": 1.0, + "content": "accuracy. Furthermore, their", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 89, + 259, + 100, + 268 + ], + "score": 1.0, + "content": "38", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 257, + 505, + 268 + ], + "score": 1.0, + "content": "choice of fixed-point precision 20 is considerably below 32, which we found to be optimal. We also", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 268, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 89, + 270, + 100, + 279 + ], + "score": 1.0, + "content": "39", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 268, + 244, + 280 + ], + "score": 1.0, + "content": "found that our implementation is", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 244, + 268, + 264, + 278 + ], + "score": 0.87, + "content": "40 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 265, + 268, + 505, + 280 + ], + "score": 1.0, + "content": "faster than theirs. Note that we use the CPU of one AWS", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 277, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 89, + 281, + 100, + 290 + ], + "score": 1.0, + "content": "40", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 277, + 506, + 292 + ], + "score": 1.0, + "content": "c5.9xlarge instance per party whereas Tan et al. use one NVIDIA Tesla V100 GPU per party. We", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 288, + 507, + 303 + ], + "spans": [ + { + "bbox": [ + 89, + 292, + 99, + 301 + ], + "score": 1.0, + "content": "41", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 288, + 507, + 303 + ], + "score": 1.0, + "content": "believe this somewhat counter-intuitive result comes from MPC heavily relying on communication,", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 300, + 386, + 313 + ], + "spans": [ + { + "bbox": [ + 89, + 303, + 100, + 312 + ], + "score": 1.0, + "content": "42", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 300, + 386, + 313 + ], + "score": 1.0, + "content": "which is an aspect where GPUs do not have an advantage over CPUs.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 90, + 319, + 99, + 328 + ], + "score": 1.0, + "content": "43", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "In this paper, we present an extensible framework for implementing deep learning training based on", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 89, + 330, + 99, + 339 + ], + "score": 1.0, + "content": "44", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "MP-SPDZ by Keller [2020], a framework for multi-party computation.1 Similar to TensorFlow and", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 89, + 341, + 100, + 351 + ], + "score": 1.0, + "content": "45", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "PyTorch, our approach allows representing deep learning models as succession of layers. We then", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 350, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 89, + 352, + 99, + 361 + ], + "score": 1.0, + "content": "46", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 350, + 505, + 362 + ], + "score": 1.0, + "content": "use this implementation to obtain accuracy figures for MNIST training by utilizing the MP-SPDZ", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 359, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 89, + 363, + 100, + 372 + ], + "score": 1.0, + "content": "47", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "score": 1.0, + "content": "emulator, which allows to run the plaintext equivalent of secure computation, that is, the same", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 89, + 374, + 99, + 383 + ], + "score": 1.0, + "content": "48", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "algorithms with the same precision. Finally, we run one of the most promising instantiation in real", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 383, + 472, + 395 + ], + "spans": [ + { + "bbox": [ + 89, + 385, + 99, + 394 + ], + "score": 1.0, + "content": "49", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "score": 1.0, + "content": "secure computation in order to benchmark it confirm the result from the plaintext emulator.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 398, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 89, + 401, + 99, + 410 + ], + "score": 1.0, + "content": "50", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 398, + 506, + 412 + ], + "score": 1.0, + "content": "There are a number of projects that integrate secure computation directly into popular machine", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 89, + 412, + 99, + 421 + ], + "score": 1.0, + "content": "51", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "learning frameworks such as CrypTen by Gunning et al. [2019], PySyft by Ryffel et al. [2018], and", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 421, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 89, + 423, + 100, + 432 + ], + "score": 1.0, + "content": "52", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "score": 1.0, + "content": "TF Encrypted by Dahl et al. [2018]. Our approach differs from all of them by running the protocol as", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 430, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 89, + 434, + 99, + 443 + ], + "score": 1.0, + "content": "53", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 430, + 261, + 445 + ], + "score": 1.0, + "content": "native CPU code (implemented using", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 262, + 432, + 282, + 442 + ], + "score": 0.84, + "content": "\\mathrm { C } { + + }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 282, + 430, + 506, + 445 + ], + "score": 1.0, + "content": "). This allows for much faster execution. For example,", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 442, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 89, + 444, + 100, + 454 + ], + "score": 1.0, + "content": "54", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "score": 1.0, + "content": "CrypTen provides an MNIST training example (mpc_autograd_cnn) that takes over one minute", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 454, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 89, + 456, + 100, + 465 + ], + "score": 1.0, + "content": "55", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 454, + 506, + 466 + ], + "score": 1.0, + "content": "to run one epoch with 100 samples on one machine. In comparison, our implementation takes 11", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 464, + 369, + 477 + ], + "spans": [ + { + "bbox": [ + 89, + 467, + 100, + 476 + ], + "score": 1.0, + "content": "56", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 464, + 369, + 477 + ], + "score": 1.0, + "content": "minutes to run one epoch with the full dataset of 60,000 samples.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 90, + 483, + 100, + 492 + ], + "score": 1.0, + "content": "57", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "Another line of work (e.g., Quoc et al. [2021]) uses trusted execution environments that provide", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 491, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 90, + 494, + 100, + 502 + ], + "score": 1.0, + "content": "58", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "score": 1.0, + "content": "computation outside the reach of the operating system. This is a different security model to multi-party", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 502, + 429, + 515 + ], + "spans": [ + { + "bbox": [ + 89, + 505, + 100, + 514 + ], + "score": 1.0, + "content": "59", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 502, + 429, + 515 + ], + "score": 1.0, + "content": "computation that works with distributing the information among several entities.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 89, + 521, + 100, + 531 + ], + "score": 1.0, + "content": "60", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "The paper is structured as follows: After introducing the basics of the protocol we use in Section 2,", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 528, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 89, + 532, + 100, + 541 + ], + "score": 1.0, + "content": "61", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 528, + 506, + 543 + ], + "score": 1.0, + "content": "we will explain the mathematical building blocks in Section 3 and their use in the context of deep", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 540, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 89, + 542, + 100, + 552 + ], + "score": 1.0, + "content": "62", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 540, + 505, + 552 + ], + "score": 1.0, + "content": "learning in Section 4. Finally, we will present our implementation in Section 5 and our experimental", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 552, + 236, + 564 + ], + "spans": [ + { + "bbox": [ + 89, + 554, + 100, + 563 + ], + "score": 1.0, + "content": "63", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 552, + 236, + 564 + ], + "score": 1.0, + "content": "results for MNIST in Section 6.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_start_line": true + } + ], + "index": 16.5, + "bbox_fs": [ + 90, + 388, + 507, + 433 + ] + }, + { + "type": "index", + "bbox": [ + 91, + 436, + 505, + 491 + ], + "lines": [], + "index": 21, + "bbox_fs": [ + 90, + 437, + 506, + 493 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 91, + 496, + 504, + 530 + ], + "lines": [], + "index": 25, + "bbox_fs": [ + 90, + 496, + 506, + 532 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 534, + 506, + 677 + ], + "lines": [], + "index": 33, + "bbox_fs": [ + 88, + 534, + 507, + 678 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 91, + 681, + 504, + 715 + ], + "lines": [], + "index": 41, + "bbox_fs": [ + 89, + 681, + 505, + 716 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 156, + 74, + 454, + 179 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 156, + 74, + 454, + 179 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 74, + 454, + 179 + ], + "spans": [ + { + "bbox": [ + 156, + 74, + 454, + 179 + ], + "score": 0.927, + "type": "image", + "image_path": "bb0f136189595323f73d65ddc0b25170a7b7ffb1f9107b9e37395cb5ee7bab1c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 156, + 74, + 454, + 109.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 156, + 109.0, + 454, + 144.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 144.0, + 454, + 179.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 191, + 505, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 506, + 204 + ], + "score": 1.0, + "content": "Figure 1: Outsourced computation: Data holders (on the left) secret-share their data to a number of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "score": 1.0, + "content": "computing parties (on the right), who then return the desired the result (e.g., a model or inference", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "results on further queries). All communication except outputs are secret-shared and thus secure if no", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 225, + 232, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 232, + 236 + ], + "score": 1.0, + "content": "two computing parties collude.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 90, + 256, + 505, + 311 + ], + "lines": [ + { + "bbox": [ + 89, + 257, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 89, + 259, + 100, + 268 + ], + "score": 1.0, + "content": "38", + "type": "text" + }, + { + "bbox": [ + 106, + 257, + 505, + 268 + ], + "score": 1.0, + "content": "choice of fixed-point precision 20 is considerably below 32, which we found to be optimal. We also", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 89, + 268, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 89, + 270, + 100, + 279 + ], + "score": 1.0, + "content": "39", + "type": "text" + }, + { + "bbox": [ + 106, + 268, + 244, + 280 + ], + "score": 1.0, + "content": "found that our implementation is", + "type": "text" + }, + { + "bbox": [ + 244, + 268, + 264, + 278 + ], + "score": 0.87, + "content": "40 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 268, + 505, + 280 + ], + "score": 1.0, + "content": "faster than theirs. Note that we use the CPU of one AWS", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 89, + 277, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 89, + 281, + 100, + 290 + ], + "score": 1.0, + "content": "40", + "type": "text" + }, + { + "bbox": [ + 105, + 277, + 506, + 292 + ], + "score": 1.0, + "content": "c5.9xlarge instance per party whereas Tan et al. use one NVIDIA Tesla V100 GPU per party. We", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 89, + 288, + 507, + 303 + ], + "spans": [ + { + "bbox": [ + 89, + 292, + 99, + 301 + ], + "score": 1.0, + "content": "41", + "type": "text" + }, + { + "bbox": [ + 105, + 288, + 507, + 303 + ], + "score": 1.0, + "content": "believe this somewhat counter-intuitive result comes from MPC heavily relying on communication,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 89, + 300, + 386, + 313 + ], + "spans": [ + { + "bbox": [ + 89, + 303, + 100, + 312 + ], + "score": 1.0, + "content": "42", + "type": "text" + }, + { + "bbox": [ + 104, + 300, + 386, + 313 + ], + "score": 1.0, + "content": "which is an aspect where GPUs do not have an advantage over CPUs.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 90, + 317, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 90, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 90, + 319, + 99, + 328 + ], + "score": 1.0, + "content": "43", + "type": "text" + }, + { + "bbox": [ + 104, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "In this paper, we present an extensible framework for implementing deep learning training based on", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 89, + 327, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 89, + 330, + 99, + 339 + ], + "score": 1.0, + "content": "44", + "type": "text" + }, + { + "bbox": [ + 105, + 327, + 505, + 340 + ], + "score": 1.0, + "content": "MP-SPDZ by Keller [2020], a framework for multi-party computation.1 Similar to TensorFlow and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 89, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 89, + 341, + 100, + 351 + ], + "score": 1.0, + "content": "45", + "type": "text" + }, + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "PyTorch, our approach allows representing deep learning models as succession of layers. We then", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 89, + 350, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 89, + 352, + 99, + 361 + ], + "score": 1.0, + "content": "46", + "type": "text" + }, + { + "bbox": [ + 105, + 350, + 505, + 362 + ], + "score": 1.0, + "content": "use this implementation to obtain accuracy figures for MNIST training by utilizing the MP-SPDZ", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 89, + 359, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 89, + 363, + 100, + 372 + ], + "score": 1.0, + "content": "47", + "type": "text" + }, + { + "bbox": [ + 105, + 359, + 506, + 374 + ], + "score": 1.0, + "content": "emulator, which allows to run the plaintext equivalent of secure computation, that is, the same", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 89, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 89, + 374, + 99, + 383 + ], + "score": 1.0, + "content": "48", + "type": "text" + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "algorithms with the same precision. Finally, we run one of the most promising instantiation in real", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 89, + 383, + 472, + 395 + ], + "spans": [ + { + "bbox": [ + 89, + 385, + 99, + 394 + ], + "score": 1.0, + "content": "49", + "type": "text" + }, + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "score": 1.0, + "content": "secure computation in order to benchmark it confirm the result from the plaintext emulator.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 90, + 398, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 89, + 398, + 506, + 412 + ], + "spans": [ + { + "bbox": [ + 89, + 401, + 99, + 410 + ], + "score": 1.0, + "content": "50", + "type": "text" + }, + { + "bbox": [ + 105, + 398, + 506, + 412 + ], + "score": 1.0, + "content": "There are a number of projects that integrate secure computation directly into popular machine", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 89, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 89, + 412, + 99, + 421 + ], + "score": 1.0, + "content": "51", + "type": "text" + }, + { + "bbox": [ + 106, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "learning frameworks such as CrypTen by Gunning et al. [2019], PySyft by Ryffel et al. [2018], and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 89, + 421, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 89, + 423, + 100, + 432 + ], + "score": 1.0, + "content": "52", + "type": "text" + }, + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "score": 1.0, + "content": "TF Encrypted by Dahl et al. [2018]. Our approach differs from all of them by running the protocol as", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 89, + 430, + 506, + 445 + ], + "spans": [ + { + "bbox": [ + 89, + 434, + 99, + 443 + ], + "score": 1.0, + "content": "53", + "type": "text" + }, + { + "bbox": [ + 105, + 430, + 261, + 445 + ], + "score": 1.0, + "content": "native CPU code (implemented using", + "type": "text" + }, + { + "bbox": [ + 262, + 432, + 282, + 442 + ], + "score": 0.84, + "content": "\\mathrm { C } { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 430, + 506, + 445 + ], + "score": 1.0, + "content": "). This allows for much faster execution. For example,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 89, + 442, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 89, + 444, + 100, + 454 + ], + "score": 1.0, + "content": "54", + "type": "text" + }, + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "score": 1.0, + "content": "CrypTen provides an MNIST training example (mpc_autograd_cnn) that takes over one minute", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 89, + 454, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 89, + 456, + 100, + 465 + ], + "score": 1.0, + "content": "55", + "type": "text" + }, + { + "bbox": [ + 105, + 454, + 506, + 466 + ], + "score": 1.0, + "content": "to run one epoch with 100 samples on one machine. In comparison, our implementation takes 11", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 89, + 464, + 369, + 477 + ], + "spans": [ + { + "bbox": [ + 89, + 467, + 100, + 476 + ], + "score": 1.0, + "content": "56", + "type": "text" + }, + { + "bbox": [ + 105, + 464, + 369, + 477 + ], + "score": 1.0, + "content": "minutes to run one epoch with the full dataset of 60,000 samples.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 90, + 480, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 90, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 90, + 483, + 100, + 492 + ], + "score": 1.0, + "content": "57", + "type": "text" + }, + { + "bbox": [ + 104, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "Another line of work (e.g., Quoc et al. [2021]) uses trusted execution environments that provide", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 90, + 491, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 90, + 494, + 100, + 502 + ], + "score": 1.0, + "content": "58", + "type": "text" + }, + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "score": 1.0, + "content": "computation outside the reach of the operating system. This is a different security model to multi-party", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 89, + 502, + 429, + 515 + ], + "spans": [ + { + "bbox": [ + 89, + 505, + 100, + 514 + ], + "score": 1.0, + "content": "59", + "type": "text" + }, + { + "bbox": [ + 105, + 502, + 429, + 515 + ], + "score": 1.0, + "content": "computation that works with distributing the information among several entities.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 90, + 519, + 505, + 563 + ], + "lines": [ + { + "bbox": [ + 89, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 89, + 521, + 100, + 531 + ], + "score": 1.0, + "content": "60", + "type": "text" + }, + { + "bbox": [ + 106, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "The paper is structured as follows: After introducing the basics of the protocol we use in Section 2,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 89, + 528, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 89, + 532, + 100, + 541 + ], + "score": 1.0, + "content": "61", + "type": "text" + }, + { + "bbox": [ + 105, + 528, + 506, + 543 + ], + "score": 1.0, + "content": "we will explain the mathematical building blocks in Section 3 and their use in the context of deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 89, + 540, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 89, + 542, + 100, + 552 + ], + "score": 1.0, + "content": "62", + "type": "text" + }, + { + "bbox": [ + 106, + 540, + 505, + 552 + ], + "score": 1.0, + "content": "learning in Section 4. Finally, we will present our implementation in Section 5 and our experimental", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 89, + 552, + 236, + 564 + ], + "spans": [ + { + "bbox": [ + 89, + 554, + 100, + 563 + ], + "score": 1.0, + "content": "63", + "type": "text" + }, + { + "bbox": [ + 105, + 552, + 236, + 564 + ], + "score": 1.0, + "content": "results for MNIST in Section 6.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5 + }, + { + "type": "title", + "bbox": [ + 91, + 578, + 405, + 592 + ], + "lines": [ + { + "bbox": [ + 87, + 578, + 407, + 595 + ], + "spans": [ + { + "bbox": [ + 87, + 578, + 407, + 595 + ], + "score": 1.0, + "content": "64 2 An Efficient Secure Multi-Party Computation Protocol", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "There is a wide range of MPC protocols with a variety of security properties (see Keller [2020] for an", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "overview). In this paper we focus on the setting of three-party computation with one semi-honest", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 624, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 639 + ], + "score": 1.0, + "content": "corruption. This means that out of the three parties two are expected to behave honestly, i.e., they", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "score": 1.0, + "content": "follow the protocol and keep their view of the protocol secret, and one party is expected to follow the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 647, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 660 + ], + "score": 1.0, + "content": "protocol but might try extract information from their view. The reason for choosing this setting is that", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "it allows an efficient MPC protocol while still allowing secure outsourced computation. The concrete", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 669, + 506, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 506, + 682 + ], + "score": 1.0, + "content": "protocol we use goes back to Benaloh and Leichter [1990] with further aspects by Araki et al. [2016],", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "score": 1.0, + "content": "Mohassel and Rindal [2018], and Eerikson et al. [2020]. We summarize the core protocol below. The", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 691, + 421, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 421, + 703 + ], + "score": 1.0, + "content": "mathematical building blocks in the next section mostly use the aspects below.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 741, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 301, + 741, + 310, + 753 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 120, + 712, + 330, + 722 + ], + "lines": [ + { + "bbox": [ + 120, + 709, + 331, + 724 + ], + "spans": [ + { + "bbox": [ + 120, + 709, + 331, + 724 + ], + "score": 1.0, + "content": "1We are committed to publishing our code as open source.", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 156, + 74, + 454, + 179 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 156, + 74, + 454, + 179 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 74, + 454, + 179 + ], + "spans": [ + { + "bbox": [ + 156, + 74, + 454, + 179 + ], + "score": 0.927, + "type": "image", + "image_path": "bb0f136189595323f73d65ddc0b25170a7b7ffb1f9107b9e37395cb5ee7bab1c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 156, + 74, + 454, + 109.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 156, + 109.0, + 454, + 144.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 144.0, + 454, + 179.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 191, + 505, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 506, + 204 + ], + "score": 1.0, + "content": "Figure 1: Outsourced computation: Data holders (on the left) secret-share their data to a number of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 215 + ], + "score": 1.0, + "content": "computing parties (on the right), who then return the desired the result (e.g., a model or inference", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "results on further queries). All communication except outputs are secret-shared and thus secure if no", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 225, + 232, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 232, + 236 + ], + "score": 1.0, + "content": "two computing parties collude.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "index", + "bbox": [ + 90, + 256, + 505, + 311 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 89, + 257, + 507, + 313 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 317, + 505, + 394 + ], + "lines": [], + "index": 15, + "bbox_fs": [ + 89, + 316, + 506, + 395 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 398, + 505, + 475 + ], + "lines": [], + "index": 22, + "bbox_fs": [ + 89, + 398, + 506, + 477 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 480, + 505, + 514 + ], + "lines": [], + "index": 27, + "bbox_fs": [ + 89, + 480, + 506, + 515 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 519, + 505, + 563 + ], + "lines": [], + "index": 30.5, + "bbox_fs": [ + 89, + 519, + 506, + 564 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 91, + 578, + 405, + 592 + ], + "lines": [ + { + "bbox": [ + 87, + 578, + 407, + 595 + ], + "spans": [ + { + "bbox": [ + 87, + 578, + 407, + 595 + ], + "score": 1.0, + "content": "64 2 An Efficient Secure Multi-Party Computation Protocol", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 603, + 505, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 506, + 617 + ], + "score": 1.0, + "content": "There is a wide range of MPC protocols with a variety of security properties (see Keller [2020] for an", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "overview). In this paper we focus on the setting of three-party computation with one semi-honest", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 624, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 639 + ], + "score": 1.0, + "content": "corruption. This means that out of the three parties two are expected to behave honestly, i.e., they", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 650 + ], + "score": 1.0, + "content": "follow the protocol and keep their view of the protocol secret, and one party is expected to follow the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 647, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 660 + ], + "score": 1.0, + "content": "protocol but might try extract information from their view. The reason for choosing this setting is that", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "it allows an efficient MPC protocol while still allowing secure outsourced computation. The concrete", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 669, + 506, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 506, + 682 + ], + "score": 1.0, + "content": "protocol we use goes back to Benaloh and Leichter [1990] with further aspects by Araki et al. [2016],", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 505, + 693 + ], + "score": 1.0, + "content": "Mohassel and Rindal [2018], and Eerikson et al. [2020]. We summarize the core protocol below. The", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 691, + 421, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 421, + 703 + ], + "score": 1.0, + "content": "mathematical building blocks in the next section mostly use the aspects below.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 604, + 506, + 703 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 90, + 72, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 89, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 89, + 74, + 99, + 84 + ], + "score": 1.0, + "content": "74", + "type": "text" + }, + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "Secret sharing All intermediate values in our protocol are stored using replicated secret sharing. A", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 89, + 83, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 89, + 86, + 100, + 95 + ], + "score": 1.0, + "content": "75", + "type": "text" + }, + { + "bbox": [ + 105, + 83, + 156, + 97 + ], + "score": 1.0, + "content": "secret value", + "type": "text" + }, + { + "bbox": [ + 156, + 86, + 163, + 93 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 83, + 298, + 97 + ], + "score": 1.0, + "content": "is a represented as a random sum", + "type": "text" + }, + { + "bbox": [ + 299, + 84, + 373, + 95 + ], + "score": 0.92, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 83, + 417, + 97 + ], + "score": 1.0, + "content": ", and party", + "type": "text" + }, + { + "bbox": [ + 417, + 84, + 428, + 95 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 83, + 453, + 97 + ], + "score": 1.0, + "content": "holds", + "type": "text" + }, + { + "bbox": [ + 454, + 84, + 505, + 96 + ], + "score": 0.92, + "content": "( x _ { i - 1 } , x _ { i + 1 } )", + "type": "inline_equation" + } + ], + "index": 1 + }, + { + "bbox": [ + 89, + 93, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 89, + 97, + 99, + 106 + ], + "score": 1.0, + "content": "76", + "type": "text" + }, + { + "bbox": [ + 105, + 93, + 505, + 108 + ], + "score": 1.0, + "content": "where the indices are computed modulo three. Clearly, each party is missing one value to compute", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 89, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 89, + 107, + 100, + 117 + ], + "score": 1.0, + "content": "77", + "type": "text" + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "the sum. On the other hand, each pair of parties hold all necessary to reconstruct the secret. For a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 89, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 89, + 118, + 100, + 128 + ], + "score": 1.0, + "content": "78", + "type": "text" + }, + { + "bbox": [ + 105, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "uniformly random generation of shares, the computation domain has to be finite. Most commonly,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 88, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 88, + 128, + 100, + 139 + ], + "score": 1.0, + "content": "79", + "type": "text" + }, + { + "bbox": [ + 105, + 126, + 392, + 140 + ], + "score": 1.0, + "content": "this domain is defined by integer computation modulo a number. We use", + "type": "text" + }, + { + "bbox": [ + 393, + 127, + 404, + 137 + ], + "score": 0.86, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 126, + 418, + 140 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 419, + 127, + 426, + 137 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "being a multiple 64", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 88, + 138, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 88, + 140, + 100, + 149 + ], + "score": 1.0, + "content": "80", + "type": "text" + }, + { + "bbox": [ + 106, + 138, + 505, + 150 + ], + "score": 1.0, + "content": "and 2 as the moduli. The first case corresponds to an extension of 64-bit arithmetic found on most", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 88, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 88, + 151, + 99, + 161 + ], + "score": 1.0, + "content": "81", + "type": "text" + }, + { + "bbox": [ + 104, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "processors. We will refer to the two settings as arithmetic and binary secret sharing throughout the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 88, + 162, + 133, + 173 + ], + "spans": [ + { + "bbox": [ + 88, + 162, + 100, + 173 + ], + "score": 1.0, + "content": "82", + "type": "text" + }, + { + "bbox": [ + 104, + 162, + 133, + 173 + ], + "score": 1.0, + "content": "paper.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 89, + 182, + 505, + 260 + ], + "lines": [ + { + "bbox": [ + 89, + 183, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 89, + 185, + 99, + 195 + ], + "score": 1.0, + "content": "83", + "type": "text" + }, + { + "bbox": [ + 105, + 183, + 506, + 196 + ], + "score": 1.0, + "content": "Input sharing The secret sharing scheme implies a protocol to share inputs where the inputting", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 89, + 194, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 89, + 196, + 100, + 205 + ], + "score": 1.0, + "content": "84", + "type": "text" + }, + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "score": 1.0, + "content": "party samples the shares and distributes them accordingly. Eerikson et al. [2020] have proposed a", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 88, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 88, + 206, + 100, + 216 + ], + "score": 1.0, + "content": "85", + "type": "text" + }, + { + "bbox": [ + 105, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "more efficient protocol where the inputting party only needs to send one value instead of two pairs of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 89, + 216, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 89, + 218, + 99, + 227 + ], + "score": 1.0, + "content": "86", + "type": "text" + }, + { + "bbox": [ + 105, + 216, + 147, + 228 + ], + "score": 1.0, + "content": "values. If", + "type": "text" + }, + { + "bbox": [ + 148, + 216, + 158, + 227 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 216, + 240, + 228 + ], + "score": 1.0, + "content": "would like to input", + "type": "text" + }, + { + "bbox": [ + 241, + 218, + 247, + 226 + ], + "score": 0.57, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 216, + 251, + 228 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 251, + 217, + 262, + 227 + ], + "score": 0.79, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 216, + 337, + 228 + ], + "score": 1.0, + "content": "is set to zero, and", + "type": "text" + }, + { + "bbox": [ + 338, + 217, + 358, + 227 + ], + "score": 0.88, + "content": "x _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 216, + 506, + 228 + ], + "score": 1.0, + "content": "is generated with a pseudo-random", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 89, + 226, + 506, + 240 + ], + "spans": [ + { + "bbox": [ + 89, + 229, + 99, + 238 + ], + "score": 1.0, + "content": "87", + "type": "text" + }, + { + "bbox": [ + 105, + 226, + 298, + 240 + ], + "score": 1.0, + "content": "generator using a key previously shared between", + "type": "text" + }, + { + "bbox": [ + 299, + 227, + 309, + 237 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 226, + 327, + 240 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 327, + 227, + 348, + 238 + ], + "score": 0.87, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 226, + 352, + 240 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 353, + 227, + 363, + 237 + ], + "score": 0.82, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 226, + 417, + 240 + ], + "score": 1.0, + "content": "can compute", + "type": "text" + }, + { + "bbox": [ + 417, + 228, + 487, + 238 + ], + "score": 0.9, + "content": "x _ { i + 1 } = x - x _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 226, + 506, + 240 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 89, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 89, + 240, + 99, + 249 + ], + "score": 1.0, + "content": "88", + "type": "text" + }, + { + "bbox": [ + 105, + 237, + 147, + 250 + ], + "score": 1.0, + "content": "send it to", + "type": "text" + }, + { + "bbox": [ + 147, + 238, + 168, + 249 + ], + "score": 0.91, + "content": "P _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 237, + 460, + 250 + ], + "score": 1.0, + "content": ". While the resulting secret sharing is not entirely random, the fact that", + "type": "text" + }, + { + "bbox": [ + 461, + 238, + 471, + 248 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "already", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 89, + 248, + 273, + 261 + ], + "spans": [ + { + "bbox": [ + 89, + 250, + 99, + 260 + ], + "score": 1.0, + "content": "89", + "type": "text" + }, + { + "bbox": [ + 105, + 248, + 135, + 261 + ], + "score": 1.0, + "content": "knows", + "type": "text" + }, + { + "bbox": [ + 135, + 251, + 142, + 258 + ], + "score": 0.73, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 248, + 223, + 261 + ], + "score": 1.0, + "content": "makes randomizing", + "type": "text" + }, + { + "bbox": [ + 224, + 250, + 234, + 259 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 248, + 273, + 261 + ], + "score": 1.0, + "content": "obsolete.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 90, + 271, + 505, + 306 + ], + "lines": [ + { + "bbox": [ + 89, + 271, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 89, + 273, + 100, + 282 + ], + "score": 1.0, + "content": "90", + "type": "text" + }, + { + "bbox": [ + 105, + 271, + 506, + 283 + ], + "score": 1.0, + "content": "Addition The commutative nature of addition allows to add secret sharings without communication.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 90, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 90, + 284, + 100, + 293 + ], + "score": 1.0, + "content": "91", + "type": "text" + }, + { + "bbox": [ + 104, + 282, + 239, + 295 + ], + "score": 1.0, + "content": "More concretely, secret sharings", + "type": "text" + }, + { + "bbox": [ + 239, + 283, + 314, + 293 + ], + "score": 0.91, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 282, + 333, + 295 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 333, + 283, + 404, + 294 + ], + "score": 0.92, + "content": "y = y _ { 0 } + y _ { 1 } + y _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "imply the secret sharing", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 88, + 293, + 291, + 306 + ], + "spans": [ + { + "bbox": [ + 88, + 293, + 106, + 306 + ], + "score": 1.0, + "content": "92", + "type": "text" + }, + { + "bbox": [ + 106, + 293, + 286, + 306 + ], + "score": 0.92, + "content": "x + y = ( x _ { 0 } + y _ { 0 } ) + ( x _ { 1 } + y _ { 1 } ) + ( x _ { 2 } + y _ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 293, + 291, + 306 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 90, + 316, + 415, + 328 + ], + "lines": [ + { + "bbox": [ + 86, + 314, + 416, + 330 + ], + "spans": [ + { + "bbox": [ + 86, + 314, + 239, + 330 + ], + "score": 1.0, + "content": "93 Multiplication The product of", + "type": "text" + }, + { + "bbox": [ + 239, + 317, + 314, + 327 + ], + "score": 0.91, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 314, + 332, + 330 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 333, + 317, + 404, + 328 + ], + "score": 0.91, + "content": "y = y _ { 0 } + y _ { 1 } + y _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 314, + 416, + 330 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "interline_equation", + "bbox": [ + 138, + 331, + 472, + 361 + ], + "lines": [ + { + "bbox": [ + 138, + 331, + 472, + 361 + ], + "spans": [ + { + "bbox": [ + 138, + 331, + 472, + 361 + ], + "score": 0.89, + "content": "{ \\begin{array} { r l } & { x \\cdot y = ( x _ { 0 } + x _ { 1 } + x _ { 2 } ) \\cdot ( y _ { 0 } + y _ { 1 } + y _ { 2 } ) } \\\\ & { \\qquad = ( x _ { 0 } y _ { 0 } + x _ { 0 } y _ { 1 } + x _ { 1 } y _ { 0 } ) + ( x _ { 1 } y _ { 1 } + x _ { 1 } y _ { 2 } + x _ { 1 } y _ { 1 } ) + ( x _ { 2 } y _ { 2 } + x _ { 2 } y _ { 0 } + x _ { 0 } y _ { 2 } ) . } \\end{array} }", + "type": "interline_equation", + "image_path": "0e562fbeff8dbe326579bda5ca198bdb7384ec8bfd3048b083e4bf0b03a38815.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 138, + 331, + 472, + 341.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 138, + 341.0, + 472, + 351.0 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 138, + 351.0, + 472, + 361.0 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "text", + "bbox": [ + 88, + 363, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 89, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 89, + 366, + 100, + 375 + ], + "score": 1.0, + "content": "94", + "type": "text" + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "Each of the brackets only contains shares known by one of the parties. They can thus compute an", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 89, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 89, + 376, + 100, + 386 + ], + "score": 1.0, + "content": "95", + "type": "text" + }, + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "additive secret sharing (one summand per party) of the product. However, every party only holding", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 89, + 386, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 89, + 388, + 100, + 397 + ], + "score": 1.0, + "content": "96", + "type": "text" + }, + { + "bbox": [ + 105, + 386, + 505, + 398 + ], + "score": 1.0, + "content": "one share does not satisfy the replication requirement for further multiplications. It is not secure", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 89, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 89, + 398, + 100, + 408 + ], + "score": 1.0, + "content": "97", + "type": "text" + }, + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "for every party to pass their value on to another party because the summands are not distributed", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 89, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 89, + 409, + 100, + 419 + ], + "score": 1.0, + "content": "98", + "type": "text" + }, + { + "bbox": [ + 105, + 407, + 326, + 420 + ], + "score": 1.0, + "content": "randomly. This can be fixed by rerandomization: Let", + "type": "text" + }, + { + "bbox": [ + 327, + 408, + 406, + 419 + ], + "score": 0.92, + "content": "x y = z _ { 0 } + z _ { 1 } + z _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 407, + 435, + 420 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 435, + 409, + 445, + 419 + ], + "score": 0.86, + "content": "z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 407, + 492, + 420 + ], + "score": 1.0, + "content": "is know to", + "type": "text" + }, + { + "bbox": [ + 492, + 408, + 503, + 419 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 407, + 506, + 420 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 88, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 88, + 420, + 100, + 431 + ], + "score": 1.0, + "content": "99", + "type": "text" + }, + { + "bbox": [ + 105, + 418, + 155, + 432 + ], + "score": 1.0, + "content": "Every party", + "type": "text" + }, + { + "bbox": [ + 155, + 419, + 167, + 429 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 418, + 208, + 432 + ], + "score": 1.0, + "content": "computes", + "type": "text" + }, + { + "bbox": [ + 208, + 419, + 309, + 430 + ], + "score": 0.92, + "content": "z _ { i } ^ { \\prime } = z _ { i } + r _ { i , i + 1 } - r _ { i - 1 , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 418, + 337, + 432 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 338, + 421, + 362, + 430 + ], + "score": 0.91, + "content": "r _ { i , i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 418, + 506, + 432 + ], + "score": 1.0, + "content": "is generated with a pseudo-random", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 86, + 428, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 86, + 431, + 100, + 442 + ], + "score": 1.0, + "content": "100", + "type": "text" + }, + { + "bbox": [ + 105, + 428, + 280, + 443 + ], + "score": 1.0, + "content": "generator using a key pre-shared between", + "type": "text" + }, + { + "bbox": [ + 280, + 430, + 291, + 440 + ], + "score": 0.86, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 428, + 310, + 443 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 311, + 430, + 331, + 441 + ], + "score": 0.9, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 428, + 414, + 443 + ], + "score": 1.0, + "content": ". The resulting sum", + "type": "text" + }, + { + "bbox": [ + 414, + 429, + 494, + 441 + ], + "score": 0.92, + "content": "x y = \\hat { z } _ { 0 } ^ { \\prime } + z _ { 1 } ^ { \\prime } + z _ { 2 } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 428, + 506, + 443 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 86, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 86, + 442, + 99, + 452 + ], + "score": 1.0, + "content": "101", + "type": "text" + }, + { + "bbox": [ + 105, + 439, + 271, + 453 + ], + "score": 1.0, + "content": "pseudo-random, and it is thus secure for", + "type": "text" + }, + { + "bbox": [ + 271, + 441, + 282, + 451 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 439, + 315, + 453 + ], + "score": 1.0, + "content": "to send", + "type": "text" + }, + { + "bbox": [ + 315, + 441, + 324, + 452 + ], + "score": 0.88, + "content": "z _ { i } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 439, + 335, + 453 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 336, + 441, + 357, + 452 + ], + "score": 0.92, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "in order to create a replicated secret", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 87, + 451, + 271, + 464 + ], + "spans": [ + { + "bbox": [ + 87, + 453, + 99, + 462 + ], + "score": 1.0, + "content": "102", + "type": "text" + }, + { + "bbox": [ + 105, + 451, + 139, + 464 + ], + "score": 1.0, + "content": "sharing", + "type": "text" + }, + { + "bbox": [ + 139, + 451, + 267, + 464 + ], + "score": 0.9, + "content": "\\left( ( x y ) _ { i - 1 } , ( x y ) _ { i + 1 } \\right) = \\left( z _ { i } ^ { \\prime } , z _ { i - 1 } ^ { \\prime } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 451, + 271, + 464 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 87, + 477, + 315, + 491 + ], + "lines": [ + { + "bbox": [ + 84, + 475, + 316, + 495 + ], + "spans": [ + { + "bbox": [ + 84, + 475, + 316, + 495 + ], + "score": 1.0, + "content": "103 3 Secure Computation Building Blocks", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 87, + 502, + 505, + 546 + ], + "lines": [ + { + "bbox": [ + 87, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 87, + 504, + 99, + 514 + ], + "score": 1.0, + "content": "104", + "type": "text" + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "In this section, we will discuss how to implement computation with MPC with a focus on how", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 86, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 86, + 515, + 100, + 524 + ], + "score": 1.0, + "content": "105", + "type": "text" + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "it differs from computation on CPUs or GPUs. Most of the techniques below are already known", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 86, + 522, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 86, + 525, + 100, + 535 + ], + "score": 1.0, + "content": "106", + "type": "text" + }, + { + "bbox": [ + 105, + 522, + 505, + 537 + ], + "score": 1.0, + "content": "individually. To the best of our knowledge however, we are the first to put them together in an efficient", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 86, + 533, + 410, + 549 + ], + "spans": [ + { + "bbox": [ + 86, + 537, + 100, + 546 + ], + "score": 1.0, + "content": "107", + "type": "text" + }, + { + "bbox": [ + 104, + 533, + 410, + 549 + ], + "score": 1.0, + "content": "and extensible framework for secure computation of deep learning training.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 86, + 557, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 86, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 86, + 560, + 99, + 569 + ], + "score": 1.0, + "content": "108", + "type": "text" + }, + { + "bbox": [ + 105, + 556, + 377, + 570 + ], + "score": 1.0, + "content": "Domain conversion Recall we that we use computation modulo", + "type": "text" + }, + { + "bbox": [ + 377, + 557, + 388, + 568 + ], + "score": 0.87, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 556, + 404, + 570 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 404, + 558, + 411, + 568 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "being a multiple of 64", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 86, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 86, + 571, + 99, + 580 + ], + "score": 1.0, + "content": "109", + "type": "text" + }, + { + "bbox": [ + 104, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "as well as 1. Given that the main operations are just addition and multiplication in the respective", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 86, + 580, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 86, + 582, + 100, + 591 + ], + "score": 1.0, + "content": "110", + "type": "text" + }, + { + "bbox": [ + 105, + 580, + 506, + 592 + ], + "score": 1.0, + "content": "domain, it is desirable to compute integer arithmetic in the large domain but operations with a", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 86, + 588, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 86, + 592, + 100, + 603 + ], + "score": 1.0, + "content": "111", + "type": "text" + }, + { + "bbox": [ + 104, + 588, + 506, + 605 + ], + "score": 1.0, + "content": "straight-forward binary circuit modulo two. There has been a long-running interest in this going", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 86, + 601, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 86, + 603, + 100, + 614 + ], + "score": 1.0, + "content": "112", + "type": "text" + }, + { + "bbox": [ + 105, + 601, + 506, + 615 + ], + "score": 1.0, + "content": "back to least Kolesnikov et al. [2013]. We mainly rely on the approach proposed by Mohassel and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 86, + 610, + 510, + 645 + ], + "spans": [ + { + "bbox": [ + 86, + 614, + 100, + 638 + ], + "score": 1.0, + "content": "113 114", + "type": "text" + }, + { + "bbox": [ + 107, + 623, + 148, + 639 + ], + "score": 0.92, + "content": "\\{ x _ { 0 } ^ { ( i ) } \\} _ { j = 0 } ^ { k - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 610, + 246, + 645 + ], + "score": 1.0, + "content": "018] and Araki et al. [20the bit decomposition of", + "type": "text" + }, + { + "bbox": [ + 246, + 626, + 257, + 636 + ], + "score": 0.85, + "content": "x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 610, + 289, + 645 + ], + "score": 1.0, + "content": ". Recal, that is,", + "type": "text" + }, + { + "bbox": [ + 289, + 623, + 342, + 638 + ], + "score": 0.93, + "content": "x _ { 0 } ^ { ( i ) } \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 612, + 339, + 622 + ], + "score": 0.9, + "content": "x \\in 2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 610, + 360, + 645 + ], + "score": 1.0, + "content": "is shand", + "type": "text" + }, + { + "bbox": [ + 360, + 623, + 435, + 638 + ], + "score": 0.94, + "content": "\\begin{array} { r } { x _ { 0 } = \\sum _ { i = 0 } ^ { k - 1 } x _ { 0 } ^ { ( i ) } 2 ^ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 613, + 466, + 623 + ], + "score": 0.89, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 610, + 510, + 645 + ], + "score": 1.0, + "content": ". Now letlf-evident", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 86, + 633, + 509, + 661 + ], + "spans": [ + { + "bbox": [ + 86, + 642, + 100, + 653 + ], + "score": 1.0, + "content": "115", + "type": "text" + }, + { + "bbox": [ + 103, + 633, + 124, + 661 + ], + "score": 1.0, + "content": "that", + "type": "text" + }, + { + "bbox": [ + 124, + 638, + 203, + 653 + ], + "score": 0.93, + "content": "x _ { 0 } ^ { ( i ) } = x _ { 0 } ^ { ( i ) } + 0 + 0", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 633, + 509, + 661 + ], + "score": 1.0, + "content": "is a valid secret sharing modulo two (albeit not a random one). Furthermore,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 86, + 649, + 510, + 673 + ], + "spans": [ + { + "bbox": [ + 86, + 657, + 100, + 666 + ], + "score": 1.0, + "content": "116", + "type": "text" + }, + { + "bbox": [ + 102, + 649, + 187, + 673 + ], + "score": 1.0, + "content": "every party holding", + "type": "text" + }, + { + "bbox": [ + 187, + 657, + 199, + 666 + ], + "score": 0.84, + "content": "x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 649, + 253, + 673 + ], + "score": 1.0, + "content": "can generate", + "type": "text" + }, + { + "bbox": [ + 253, + 652, + 270, + 667 + ], + "score": 0.91, + "content": "x _ { 0 } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 649, + 510, + 673 + ], + "score": 1.0, + "content": ". It is therefore possible for the parties to generate a secret", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 86, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 99, + 678 + ], + "score": 1.0, + "content": "117", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 294, + 680 + ], + "score": 1.0, + "content": "sharing modulo two of a single share modulo", + "type": "text" + }, + { + "bbox": [ + 294, + 666, + 305, + 677 + ], + "score": 0.86, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 666, + 506, + 680 + ], + "score": 1.0, + "content": ". Repeating this for all shares and the computing", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 86, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 100, + 689 + ], + "score": 1.0, + "content": "118", + "type": "text" + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "the addition as a binary circuit allows the parties to generate a secret sharing modulo two from a", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 86, + 687, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 100, + 700 + ], + "score": 1.0, + "content": "119", + "type": "text" + }, + { + "bbox": [ + 104, + 687, + 195, + 702 + ], + "score": 1.0, + "content": "secret sharing modulo", + "type": "text" + }, + { + "bbox": [ + 195, + 688, + 206, + 699 + ], + "score": 0.85, + "content": "\\bar { 2 } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 687, + 506, + 702 + ], + "score": 1.0, + "content": ". Conversion in the other direction can be achieved using a similar technique", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 86, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 100, + 711 + ], + "score": 1.0, + "content": "120", + "type": "text" + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "or using daBits as described by Rotaru and Wood [2019]. In the following we will use the term", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 86, + 710, + 462, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 99, + 722 + ], + "score": 1.0, + "content": "121", + "type": "text" + }, + { + "bbox": [ + 104, + 710, + 462, + 724 + ], + "score": 1.0, + "content": "mixed-circuit computation for any technique that works over both computation domains.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 43 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "index", + "bbox": [ + 90, + 72, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 89, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 89, + 74, + 99, + 84 + ], + "score": 1.0, + "content": "74", + "type": "text" + }, + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "Secret sharing All intermediate values in our protocol are stored using replicated secret sharing. A", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 83, + 505, + 97 + ], + "spans": [ + { + "bbox": [ + 89, + 86, + 100, + 95 + ], + "score": 1.0, + "content": "75", + "type": "text" + }, + { + "bbox": [ + 105, + 83, + 156, + 97 + ], + "score": 1.0, + "content": "secret value", + "type": "text" + }, + { + "bbox": [ + 156, + 86, + 163, + 93 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 83, + 298, + 97 + ], + "score": 1.0, + "content": "is a represented as a random sum", + "type": "text" + }, + { + "bbox": [ + 299, + 84, + 373, + 95 + ], + "score": 0.92, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 83, + 417, + 97 + ], + "score": 1.0, + "content": ", and party", + "type": "text" + }, + { + "bbox": [ + 417, + 84, + 428, + 95 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 83, + 453, + 97 + ], + "score": 1.0, + "content": "holds", + "type": "text" + }, + { + "bbox": [ + 454, + 84, + 505, + 96 + ], + "score": 0.92, + "content": "( x _ { i - 1 } , x _ { i + 1 } )", + "type": "inline_equation" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 93, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 89, + 97, + 99, + 106 + ], + "score": 1.0, + "content": "76", + "type": "text" + }, + { + "bbox": [ + 105, + 93, + 505, + 108 + ], + "score": 1.0, + "content": "where the indices are computed modulo three. Clearly, each party is missing one value to compute", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 89, + 107, + 100, + 117 + ], + "score": 1.0, + "content": "77", + "type": "text" + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "the sum. On the other hand, each pair of parties hold all necessary to reconstruct the secret. For a", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 89, + 118, + 100, + 128 + ], + "score": 1.0, + "content": "78", + "type": "text" + }, + { + "bbox": [ + 105, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "uniformly random generation of shares, the computation domain has to be finite. Most commonly,", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 126, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 88, + 128, + 100, + 139 + ], + "score": 1.0, + "content": "79", + "type": "text" + }, + { + "bbox": [ + 105, + 126, + 392, + 140 + ], + "score": 1.0, + "content": "this domain is defined by integer computation modulo a number. We use", + "type": "text" + }, + { + "bbox": [ + 393, + 127, + 404, + 137 + ], + "score": 0.86, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 126, + 418, + 140 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 419, + 127, + 426, + 137 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 126, + 505, + 140 + ], + "score": 1.0, + "content": "being a multiple 64", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 138, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 88, + 140, + 100, + 149 + ], + "score": 1.0, + "content": "80", + "type": "text" + }, + { + "bbox": [ + 106, + 138, + 505, + 150 + ], + "score": 1.0, + "content": "and 2 as the moduli. The first case corresponds to an extension of 64-bit arithmetic found on most", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 88, + 151, + 99, + 161 + ], + "score": 1.0, + "content": "81", + "type": "text" + }, + { + "bbox": [ + 104, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "processors. We will refer to the two settings as arithmetic and binary secret sharing throughout the", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 162, + 133, + 173 + ], + "spans": [ + { + "bbox": [ + 88, + 162, + 100, + 173 + ], + "score": 1.0, + "content": "82", + "type": "text" + }, + { + "bbox": [ + 104, + 162, + 133, + 173 + ], + "score": 1.0, + "content": "paper.", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 183, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 89, + 185, + 99, + 195 + ], + "score": 1.0, + "content": "83", + "type": "text" + }, + { + "bbox": [ + 105, + 183, + 506, + 196 + ], + "score": 1.0, + "content": "Input sharing The secret sharing scheme implies a protocol to share inputs where the inputting", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 194, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 89, + 196, + 100, + 205 + ], + "score": 1.0, + "content": "84", + "type": "text" + }, + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "score": 1.0, + "content": "party samples the shares and distributes them accordingly. Eerikson et al. [2020] have proposed a", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 88, + 206, + 100, + 216 + ], + "score": 1.0, + "content": "85", + "type": "text" + }, + { + "bbox": [ + 105, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "more efficient protocol where the inputting party only needs to send one value instead of two pairs of", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 216, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 89, + 218, + 99, + 227 + ], + "score": 1.0, + "content": "86", + "type": "text" + }, + { + "bbox": [ + 105, + 216, + 147, + 228 + ], + "score": 1.0, + "content": "values. If", + "type": "text" + }, + { + "bbox": [ + 148, + 216, + 158, + 227 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 216, + 240, + 228 + ], + "score": 1.0, + "content": "would like to input", + "type": "text" + }, + { + "bbox": [ + 241, + 218, + 247, + 226 + ], + "score": 0.57, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 216, + 251, + 228 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 251, + 217, + 262, + 227 + ], + "score": 0.79, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 216, + 337, + 228 + ], + "score": 1.0, + "content": "is set to zero, and", + "type": "text" + }, + { + "bbox": [ + 338, + 217, + 358, + 227 + ], + "score": 0.88, + "content": "x _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 216, + 506, + 228 + ], + "score": 1.0, + "content": "is generated with a pseudo-random", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 226, + 506, + 240 + ], + "spans": [ + { + "bbox": [ + 89, + 229, + 99, + 238 + ], + "score": 1.0, + "content": "87", + "type": "text" + }, + { + "bbox": [ + 105, + 226, + 298, + 240 + ], + "score": 1.0, + "content": "generator using a key previously shared between", + "type": "text" + }, + { + "bbox": [ + 299, + 227, + 309, + 237 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 226, + 327, + 240 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 327, + 227, + 348, + 238 + ], + "score": 0.87, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 226, + 352, + 240 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 353, + 227, + 363, + 237 + ], + "score": 0.82, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 226, + 417, + 240 + ], + "score": 1.0, + "content": "can compute", + "type": "text" + }, + { + "bbox": [ + 417, + 228, + 487, + 238 + ], + "score": 0.9, + "content": "x _ { i + 1 } = x - x _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 226, + 506, + 240 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 89, + 240, + 99, + 249 + ], + "score": 1.0, + "content": "88", + "type": "text" + }, + { + "bbox": [ + 105, + 237, + 147, + 250 + ], + "score": 1.0, + "content": "send it to", + "type": "text" + }, + { + "bbox": [ + 147, + 238, + 168, + 249 + ], + "score": 0.91, + "content": "P _ { i - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 237, + 460, + 250 + ], + "score": 1.0, + "content": ". While the resulting secret sharing is not entirely random, the fact that", + "type": "text" + }, + { + "bbox": [ + 461, + 238, + 471, + 248 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "already", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 248, + 273, + 261 + ], + "spans": [ + { + "bbox": [ + 89, + 250, + 99, + 260 + ], + "score": 1.0, + "content": "89", + "type": "text" + }, + { + "bbox": [ + 105, + 248, + 135, + 261 + ], + "score": 1.0, + "content": "knows", + "type": "text" + }, + { + "bbox": [ + 135, + 251, + 142, + 258 + ], + "score": 0.73, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 248, + 223, + 261 + ], + "score": 1.0, + "content": "makes randomizing", + "type": "text" + }, + { + "bbox": [ + 224, + 250, + 234, + 259 + ], + "score": 0.85, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 248, + 273, + 261 + ], + "score": 1.0, + "content": "obsolete.", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 271, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 89, + 273, + 100, + 282 + ], + "score": 1.0, + "content": "90", + "type": "text" + }, + { + "bbox": [ + 105, + 271, + 506, + 283 + ], + "score": 1.0, + "content": "Addition The commutative nature of addition allows to add secret sharings without communication.", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 90, + 284, + 100, + 293 + ], + "score": 1.0, + "content": "91", + "type": "text" + }, + { + "bbox": [ + 104, + 282, + 239, + 295 + ], + "score": 1.0, + "content": "More concretely, secret sharings", + "type": "text" + }, + { + "bbox": [ + 239, + 283, + 314, + 293 + ], + "score": 0.91, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 282, + 333, + 295 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 333, + 283, + 404, + 294 + ], + "score": 0.92, + "content": "y = y _ { 0 } + y _ { 1 } + y _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "imply the secret sharing", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 293, + 291, + 306 + ], + "spans": [ + { + "bbox": [ + 88, + 293, + 106, + 306 + ], + "score": 1.0, + "content": "92", + "type": "text" + }, + { + "bbox": [ + 106, + 293, + 286, + 306 + ], + "score": 0.92, + "content": "x + y = ( x _ { 0 } + y _ { 0 } ) + ( x _ { 1 } + y _ { 1 } ) + ( x _ { 2 } + y _ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 293, + 291, + 306 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + } + ], + "index": 4, + "bbox_fs": [ + 88, + 72, + 506, + 173 + ] + }, + { + "type": "index", + "bbox": [ + 89, + 182, + 505, + 260 + ], + "lines": [], + "index": 12, + "bbox_fs": [ + 88, + 183, + 506, + 261 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 90, + 271, + 505, + 306 + ], + "lines": [], + "index": 17, + "bbox_fs": [ + 88, + 271, + 506, + 306 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 90, + 316, + 415, + 328 + ], + "lines": [ + { + "bbox": [ + 86, + 314, + 416, + 330 + ], + "spans": [ + { + "bbox": [ + 86, + 314, + 239, + 330 + ], + "score": 1.0, + "content": "93 Multiplication The product of", + "type": "text" + }, + { + "bbox": [ + 239, + 317, + 314, + 327 + ], + "score": 0.91, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 314, + 332, + 330 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 333, + 317, + 404, + 328 + ], + "score": 0.91, + "content": "y = y _ { 0 } + y _ { 1 } + y _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 314, + 416, + 330 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19, + "bbox_fs": [ + 86, + 314, + 416, + 330 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 138, + 331, + 472, + 361 + ], + "lines": [ + { + "bbox": [ + 138, + 331, + 472, + 361 + ], + "spans": [ + { + "bbox": [ + 138, + 331, + 472, + 361 + ], + "score": 0.89, + "content": "{ \\begin{array} { r l } & { x \\cdot y = ( x _ { 0 } + x _ { 1 } + x _ { 2 } ) \\cdot ( y _ { 0 } + y _ { 1 } + y _ { 2 } ) } \\\\ & { \\qquad = ( x _ { 0 } y _ { 0 } + x _ { 0 } y _ { 1 } + x _ { 1 } y _ { 0 } ) + ( x _ { 1 } y _ { 1 } + x _ { 1 } y _ { 2 } + x _ { 1 } y _ { 1 } ) + ( x _ { 2 } y _ { 2 } + x _ { 2 } y _ { 0 } + x _ { 0 } y _ { 2 } ) . } \\end{array} }", + "type": "interline_equation", + "image_path": "0e562fbeff8dbe326579bda5ca198bdb7384ec8bfd3048b083e4bf0b03a38815.jpg" + } + ] + } + ], + "index": 21, + "virtual_lines": [ + { + "bbox": [ + 138, + 331, + 472, + 341.0 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 138, + 341.0, + 472, + 351.0 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 138, + 351.0, + 472, + 361.0 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "index", + "bbox": [ + 88, + 363, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 89, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 89, + 366, + 100, + 375 + ], + "score": 1.0, + "content": "94", + "type": "text" + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "Each of the brackets only contains shares known by one of the parties. They can thus compute an", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 374, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 89, + 376, + 100, + 386 + ], + "score": 1.0, + "content": "95", + "type": "text" + }, + { + "bbox": [ + 105, + 374, + 505, + 388 + ], + "score": 1.0, + "content": "additive secret sharing (one summand per party) of the product. However, every party only holding", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 386, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 89, + 388, + 100, + 397 + ], + "score": 1.0, + "content": "96", + "type": "text" + }, + { + "bbox": [ + 105, + 386, + 505, + 398 + ], + "score": 1.0, + "content": "one share does not satisfy the replication requirement for further multiplications. It is not secure", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 89, + 398, + 100, + 408 + ], + "score": 1.0, + "content": "97", + "type": "text" + }, + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "for every party to pass their value on to another party because the summands are not distributed", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 89, + 409, + 100, + 419 + ], + "score": 1.0, + "content": "98", + "type": "text" + }, + { + "bbox": [ + 105, + 407, + 326, + 420 + ], + "score": 1.0, + "content": "randomly. This can be fixed by rerandomization: Let", + "type": "text" + }, + { + "bbox": [ + 327, + 408, + 406, + 419 + ], + "score": 0.92, + "content": "x y = z _ { 0 } + z _ { 1 } + z _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 407, + 435, + 420 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 435, + 409, + 445, + 419 + ], + "score": 0.86, + "content": "z _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 407, + 492, + 420 + ], + "score": 1.0, + "content": "is know to", + "type": "text" + }, + { + "bbox": [ + 492, + 408, + 503, + 419 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 407, + 506, + 420 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 88, + 420, + 100, + 431 + ], + "score": 1.0, + "content": "99", + "type": "text" + }, + { + "bbox": [ + 105, + 418, + 155, + 432 + ], + "score": 1.0, + "content": "Every party", + "type": "text" + }, + { + "bbox": [ + 155, + 419, + 167, + 429 + ], + "score": 0.87, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 418, + 208, + 432 + ], + "score": 1.0, + "content": "computes", + "type": "text" + }, + { + "bbox": [ + 208, + 419, + 309, + 430 + ], + "score": 0.92, + "content": "z _ { i } ^ { \\prime } = z _ { i } + r _ { i , i + 1 } - r _ { i - 1 , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 418, + 337, + 432 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 338, + 421, + 362, + 430 + ], + "score": 0.91, + "content": "r _ { i , i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 418, + 506, + 432 + ], + "score": 1.0, + "content": "is generated with a pseudo-random", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 428, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 86, + 431, + 100, + 442 + ], + "score": 1.0, + "content": "100", + "type": "text" + }, + { + "bbox": [ + 105, + 428, + 280, + 443 + ], + "score": 1.0, + "content": "generator using a key pre-shared between", + "type": "text" + }, + { + "bbox": [ + 280, + 430, + 291, + 440 + ], + "score": 0.86, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 428, + 310, + 443 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 311, + 430, + 331, + 441 + ], + "score": 0.9, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 428, + 414, + 443 + ], + "score": 1.0, + "content": ". The resulting sum", + "type": "text" + }, + { + "bbox": [ + 414, + 429, + 494, + 441 + ], + "score": 0.92, + "content": "x y = \\hat { z } _ { 0 } ^ { \\prime } + z _ { 1 } ^ { \\prime } + z _ { 2 } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 428, + 506, + 443 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 439, + 506, + 453 + ], + "spans": [ + { + "bbox": [ + 86, + 442, + 99, + 452 + ], + "score": 1.0, + "content": "101", + "type": "text" + }, + { + "bbox": [ + 105, + 439, + 271, + 453 + ], + "score": 1.0, + "content": "pseudo-random, and it is thus secure for", + "type": "text" + }, + { + "bbox": [ + 271, + 441, + 282, + 451 + ], + "score": 0.88, + "content": "P _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 439, + 315, + 453 + ], + "score": 1.0, + "content": "to send", + "type": "text" + }, + { + "bbox": [ + 315, + 441, + 324, + 452 + ], + "score": 0.88, + "content": "z _ { i } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 439, + 335, + 453 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 336, + 441, + 357, + 452 + ], + "score": 0.92, + "content": "P _ { i + 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 439, + 506, + 453 + ], + "score": 1.0, + "content": "in order to create a replicated secret", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 87, + 451, + 271, + 464 + ], + "spans": [ + { + "bbox": [ + 87, + 453, + 99, + 462 + ], + "score": 1.0, + "content": "102", + "type": "text" + }, + { + "bbox": [ + 105, + 451, + 139, + 464 + ], + "score": 1.0, + "content": "sharing", + "type": "text" + }, + { + "bbox": [ + 139, + 451, + 267, + 464 + ], + "score": 0.9, + "content": "\\left( ( x y ) _ { i - 1 } , ( x y ) _ { i + 1 } \\right) = \\left( z _ { i } ^ { \\prime } , z _ { i - 1 } ^ { \\prime } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 451, + 271, + 464 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + } + ], + "index": 27, + "bbox_fs": [ + 86, + 363, + 506, + 464 + ] + }, + { + "type": "title", + "bbox": [ + 87, + 477, + 315, + 491 + ], + "lines": [ + { + "bbox": [ + 84, + 475, + 316, + 495 + ], + "spans": [ + { + "bbox": [ + 84, + 475, + 316, + 495 + ], + "score": 1.0, + "content": "103 3 Secure Computation Building Blocks", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "index", + "bbox": [ + 87, + 502, + 505, + 546 + ], + "lines": [ + { + "bbox": [ + 87, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 87, + 504, + 99, + 514 + ], + "score": 1.0, + "content": "104", + "type": "text" + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "In this section, we will discuss how to implement computation with MPC with a focus on how", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 86, + 515, + 100, + 524 + ], + "score": 1.0, + "content": "105", + "type": "text" + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "it differs from computation on CPUs or GPUs. Most of the techniques below are already known", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 522, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 86, + 525, + 100, + 535 + ], + "score": 1.0, + "content": "106", + "type": "text" + }, + { + "bbox": [ + 105, + 522, + 505, + 537 + ], + "score": 1.0, + "content": "individually. To the best of our knowledge however, we are the first to put them together in an efficient", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 533, + 410, + 549 + ], + "spans": [ + { + "bbox": [ + 86, + 537, + 100, + 546 + ], + "score": 1.0, + "content": "107", + "type": "text" + }, + { + "bbox": [ + 104, + 533, + 410, + 549 + ], + "score": 1.0, + "content": "and extensible framework for secure computation of deep learning training.", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 86, + 560, + 99, + 569 + ], + "score": 1.0, + "content": "108", + "type": "text" + }, + { + "bbox": [ + 105, + 556, + 377, + 570 + ], + "score": 1.0, + "content": "Domain conversion Recall we that we use computation modulo", + "type": "text" + }, + { + "bbox": [ + 377, + 557, + 388, + 568 + ], + "score": 0.87, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 556, + 404, + 570 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 404, + 558, + 411, + 568 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "being a multiple of 64", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 86, + 571, + 99, + 580 + ], + "score": 1.0, + "content": "109", + "type": "text" + }, + { + "bbox": [ + 104, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "as well as 1. Given that the main operations are just addition and multiplication in the respective", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 580, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 86, + 582, + 100, + 591 + ], + "score": 1.0, + "content": "110", + "type": "text" + }, + { + "bbox": [ + 105, + 580, + 506, + 592 + ], + "score": 1.0, + "content": "domain, it is desirable to compute integer arithmetic in the large domain but operations with a", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 588, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 86, + 592, + 100, + 603 + ], + "score": 1.0, + "content": "111", + "type": "text" + }, + { + "bbox": [ + 104, + 588, + 506, + 605 + ], + "score": 1.0, + "content": "straight-forward binary circuit modulo two. There has been a long-running interest in this going", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 601, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 86, + 603, + 100, + 614 + ], + "score": 1.0, + "content": "112", + "type": "text" + }, + { + "bbox": [ + 105, + 601, + 506, + 615 + ], + "score": 1.0, + "content": "back to least Kolesnikov et al. [2013]. We mainly rely on the approach proposed by Mohassel and", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 610, + 510, + 645 + ], + "spans": [ + { + "bbox": [ + 86, + 614, + 100, + 638 + ], + "score": 1.0, + "content": "113 114", + "type": "text" + }, + { + "bbox": [ + 107, + 623, + 148, + 639 + ], + "score": 0.92, + "content": "\\{ x _ { 0 } ^ { ( i ) } \\} _ { j = 0 } ^ { k - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 610, + 246, + 645 + ], + "score": 1.0, + "content": "018] and Araki et al. [20the bit decomposition of", + "type": "text" + }, + { + "bbox": [ + 246, + 626, + 257, + 636 + ], + "score": 0.85, + "content": "x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 610, + 289, + 645 + ], + "score": 1.0, + "content": ". Recal, that is,", + "type": "text" + }, + { + "bbox": [ + 289, + 623, + 342, + 638 + ], + "score": 0.93, + "content": "x _ { 0 } ^ { ( i ) } \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 612, + 339, + 622 + ], + "score": 0.9, + "content": "x \\in 2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 610, + 360, + 645 + ], + "score": 1.0, + "content": "is shand", + "type": "text" + }, + { + "bbox": [ + 360, + 623, + 435, + 638 + ], + "score": 0.94, + "content": "\\begin{array} { r } { x _ { 0 } = \\sum _ { i = 0 } ^ { k - 1 } x _ { 0 } ^ { ( i ) } 2 ^ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 613, + 466, + 623 + ], + "score": 0.89, + "content": "x = x _ { 0 } + x _ { 1 } + x _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 610, + 510, + 645 + ], + "score": 1.0, + "content": ". Now letlf-evident", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 633, + 509, + 661 + ], + "spans": [ + { + "bbox": [ + 86, + 642, + 100, + 653 + ], + "score": 1.0, + "content": "115", + "type": "text" + }, + { + "bbox": [ + 103, + 633, + 124, + 661 + ], + "score": 1.0, + "content": "that", + "type": "text" + }, + { + "bbox": [ + 124, + 638, + 203, + 653 + ], + "score": 0.93, + "content": "x _ { 0 } ^ { ( i ) } = x _ { 0 } ^ { ( i ) } + 0 + 0", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 633, + 509, + 661 + ], + "score": 1.0, + "content": "is a valid secret sharing modulo two (albeit not a random one). Furthermore,", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 649, + 510, + 673 + ], + "spans": [ + { + "bbox": [ + 86, + 657, + 100, + 666 + ], + "score": 1.0, + "content": "116", + "type": "text" + }, + { + "bbox": [ + 102, + 649, + 187, + 673 + ], + "score": 1.0, + "content": "every party holding", + "type": "text" + }, + { + "bbox": [ + 187, + 657, + 199, + 666 + ], + "score": 0.84, + "content": "x _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 649, + 253, + 673 + ], + "score": 1.0, + "content": "can generate", + "type": "text" + }, + { + "bbox": [ + 253, + 652, + 270, + 667 + ], + "score": 0.91, + "content": "x _ { 0 } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 649, + 510, + 673 + ], + "score": 1.0, + "content": ". It is therefore possible for the parties to generate a secret", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 99, + 678 + ], + "score": 1.0, + "content": "117", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 294, + 680 + ], + "score": 1.0, + "content": "sharing modulo two of a single share modulo", + "type": "text" + }, + { + "bbox": [ + 294, + 666, + 305, + 677 + ], + "score": 0.86, + "content": "2 ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 666, + 506, + 680 + ], + "score": 1.0, + "content": ". Repeating this for all shares and the computing", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 100, + 689 + ], + "score": 1.0, + "content": "118", + "type": "text" + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "the addition as a binary circuit allows the parties to generate a secret sharing modulo two from a", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 687, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 100, + 700 + ], + "score": 1.0, + "content": "119", + "type": "text" + }, + { + "bbox": [ + 104, + 687, + 195, + 702 + ], + "score": 1.0, + "content": "secret sharing modulo", + "type": "text" + }, + { + "bbox": [ + 195, + 688, + 206, + 699 + ], + "score": 0.85, + "content": "\\bar { 2 } ^ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 687, + 506, + 702 + ], + "score": 1.0, + "content": ". Conversion in the other direction can be achieved using a similar technique", + "type": "text" + } + ], + "index": 47, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 100, + 711 + ], + "score": 1.0, + "content": "120", + "type": "text" + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "or using daBits as described by Rotaru and Wood [2019]. In the following we will use the term", + "type": "text" + } + ], + "index": 48, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 710, + 462, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 99, + 722 + ], + "score": 1.0, + "content": "121", + "type": "text" + }, + { + "bbox": [ + 104, + 710, + 462, + 724 + ], + "score": 1.0, + "content": "mixed-circuit computation for any technique that works over both computation domains.", + "type": "text" + } + ], + "index": 49, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 100, + 84 + ], + "score": 1.0, + "content": "122", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "Quantization While Aliasgari et al. [2013] showed that it is possible to implement floating-point", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 86, + 86, + 100, + 96 + ], + "score": 1.0, + "content": "123", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "computation, the cost is far higher than integer computation. It is therefore common to represent", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 95, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 86, + 96, + 100, + 106 + ], + "score": 1.0, + "content": "124", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 95, + 506, + 107 + ], + "score": 1.0, + "content": "fractional numbers using quantization (also called fixed-point representation) as suggested by Catrina", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 103, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 86, + 108, + 100, + 117 + ], + "score": 1.0, + "content": "125", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 103, + 245, + 120 + ], + "score": 1.0, + "content": "and Saxena [2010]. A real number", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 246, + 108, + 253, + 115 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 253, + 103, + 322, + 120 + ], + "score": 1.0, + "content": "is represented as", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 322, + 105, + 374, + 118 + ], + "score": 0.93, + "content": "\\bar { \\boldsymbol { x } } = \\lfloor \\boldsymbol { x } \\cdot \\mathbf { \\bar { 2 } } ^ { f } \\rceil", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 374, + 103, + 402, + 120 + ], + "score": 1.0, + "content": "where", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 402, + 106, + 409, + 117 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 410, + 103, + 506, + 120 + ], + "score": 1.0, + "content": "is an integer specifying", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 86, + 118, + 100, + 128 + ], + "score": 1.0, + "content": "126", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "the precision. The linearity of the representation allows to compute addition by simply adding the", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 86, + 129, + 100, + 139 + ], + "score": 1.0, + "content": "127", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "representing integers. Multiplication however requires to adjust the result because it will have twice", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 137, + 423, + 151 + ], + "spans": [ + { + "bbox": [ + 86, + 140, + 100, + 150 + ], + "score": 1.0, + "content": "128", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 137, + 164, + 151 + ], + "score": 1.0, + "content": "the precision:", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 164, + 137, + 279, + 150 + ], + "score": 0.93, + "content": "( x \\cdot 2 ^ { f } ) \\cdot ( y \\cdot \\dot { 2 } ^ { f } ) = x y \\cdot 2 ^ { 2 f }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 279, + 137, + 423, + 151 + ], + "score": 1.0, + "content": ". There are two ways to rectify this:", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + } + ], + "index": 34.5, + "bbox_fs": [ + 86, + 501, + 505, + 549 + ] + }, + { + "type": "index", + "bbox": [ + 86, + 557, + 505, + 722 + ], + "lines": [], + "index": 43, + "bbox_fs": [ + 86, + 556, + 510, + 724 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 87, + 72, + 505, + 150 + ], + "lines": [ + { + "bbox": [ + 86, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 100, + 84 + ], + "score": 1.0, + "content": "122", + "type": "text" + }, + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "Quantization While Aliasgari et al. [2013] showed that it is possible to implement floating-point", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 86, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 86, + 86, + 100, + 96 + ], + "score": 1.0, + "content": "123", + "type": "text" + }, + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "computation, the cost is far higher than integer computation. It is therefore common to represent", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 86, + 95, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 86, + 96, + 100, + 106 + ], + "score": 1.0, + "content": "124", + "type": "text" + }, + { + "bbox": [ + 106, + 95, + 506, + 107 + ], + "score": 1.0, + "content": "fractional numbers using quantization (also called fixed-point representation) as suggested by Catrina", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 86, + 103, + 506, + 120 + ], + "spans": [ + { + "bbox": [ + 86, + 108, + 100, + 117 + ], + "score": 1.0, + "content": "125", + "type": "text" + }, + { + "bbox": [ + 104, + 103, + 245, + 120 + ], + "score": 1.0, + "content": "and Saxena [2010]. A real number", + "type": "text" + }, + { + "bbox": [ + 246, + 108, + 253, + 115 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 103, + 322, + 120 + ], + "score": 1.0, + "content": "is represented as", + "type": "text" + }, + { + "bbox": [ + 322, + 105, + 374, + 118 + ], + "score": 0.93, + "content": "\\bar { \\boldsymbol { x } } = \\lfloor \\boldsymbol { x } \\cdot \\mathbf { \\bar { 2 } } ^ { f } \\rceil", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 103, + 402, + 120 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 402, + 106, + 409, + 117 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 103, + 506, + 120 + ], + "score": 1.0, + "content": "is an integer specifying", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 86, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 86, + 118, + 100, + 128 + ], + "score": 1.0, + "content": "126", + "type": "text" + }, + { + "bbox": [ + 105, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "the precision. The linearity of the representation allows to compute addition by simply adding the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 86, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 86, + 129, + 100, + 139 + ], + "score": 1.0, + "content": "127", + "type": "text" + }, + { + "bbox": [ + 104, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "representing integers. Multiplication however requires to adjust the result because it will have twice", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 86, + 137, + 423, + 151 + ], + "spans": [ + { + "bbox": [ + 86, + 140, + 100, + 150 + ], + "score": 1.0, + "content": "128", + "type": "text" + }, + { + "bbox": [ + 105, + 137, + 164, + 151 + ], + "score": 1.0, + "content": "the precision:", + "type": "text" + }, + { + "bbox": [ + 164, + 137, + 279, + 150 + ], + "score": 0.93, + "content": "( x \\cdot 2 ^ { f } ) \\cdot ( y \\cdot \\dot { 2 } ^ { f } ) = x y \\cdot 2 ^ { 2 f }", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 137, + 423, + 151 + ], + "score": 1.0, + "content": ". There are two ways to rectify this:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 134, + 159, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 133, + 158, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 133, + 158, + 353, + 173 + ], + "score": 1.0, + "content": "• An obvious correction would be to shift the result by", + "type": "text" + }, + { + "bbox": [ + 353, + 160, + 360, + 172 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 158, + 428, + 173 + ], + "score": 1.0, + "content": "bits after adding", + "type": "text" + }, + { + "bbox": [ + 428, + 159, + 450, + 170 + ], + "score": 0.91, + "content": "2 ^ { f - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 158, + 506, + 173 + ], + "score": 1.0, + "content": "to the integer", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 171, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 141, + 171, + 506, + 183 + ], + "score": 1.0, + "content": "representation. This ensures rounding to the nearest number possible in the representation,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 141, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "with the tie being broken by rounding up. Dalskov et al. [2021] presented an efficient", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 193, + 410, + 205 + ], + "spans": [ + { + "bbox": [ + 142, + 193, + 410, + 205 + ], + "score": 1.0, + "content": "implementation of the truncation using mixed-circuit computation.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 133, + 208, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 132, + 208, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 132, + 208, + 506, + 221 + ], + "score": 1.0, + "content": "• However, Catrina and Saxena have found that in the context of secure computation it is more", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 219, + 504, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 219, + 504, + 231 + ], + "score": 1.0, + "content": "efficient to use probabilistic truncation. This method rounds up or down probabilistically", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 230, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 505, + 243 + ], + "score": 1.0, + "content": "depending on the input. For example, probabilistically rounding 0.75 to an integer would", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 142, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "see it rounded of up with probability 0.75 and down with probability 0.25. The probabilistic", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 252, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 142, + 252, + 505, + 264 + ], + "score": 1.0, + "content": "truncation is an effect of the fact that the operation involves the truncation of a randomized", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 262, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 262, + 272, + 277 + ], + "score": 1.0, + "content": "value, that is the computation of", + "type": "text" + }, + { + "bbox": [ + 272, + 263, + 329, + 275 + ], + "score": 0.92, + "content": "\\left\\lfloor ( x + r ) / 2 ^ { m } \\right\\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 262, + 383, + 277 + ], + "score": 1.0, + "content": "for a random", + "type": "text" + }, + { + "bbox": [ + 384, + 264, + 393, + 273 + ], + "score": 0.79, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 262, + 432, + 277 + ], + "score": 1.0, + "content": "-bit value", + "type": "text" + }, + { + "bbox": [ + 432, + 265, + 438, + 273 + ], + "score": 0.74, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 262, + 506, + 277 + ], + "score": 1.0, + "content": ". It is easy to see", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 273, + 162, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 162, + 286 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14 + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 284, + 441, + 312 + ], + "lines": [ + { + "bbox": [ + 205, + 284, + 441, + 312 + ], + "spans": [ + { + "bbox": [ + 205, + 284, + 441, + 312 + ], + "score": 0.92, + "content": "\\lfloor ( x + r ) / 2 ^ { m } \\rfloor = \\left\\{ \\begin{array} { l l } { \\lfloor x / 2 ^ { m } \\rfloor } & { ( x \\bmod 2 ^ { m } + r ) < 2 ^ { m } } \\\\ { \\lfloor x / 2 ^ { m } \\rfloor + 1 } & { ( x \\bmod 2 ^ { m } + r ) \\ge 2 ^ { m } . } \\end{array} \\right.", + "type": "interline_equation", + "image_path": "8c5c9712adea6b5b528c5e11a746ad687533c04d65eda8941ed882721c5e70cc.jpg" + } + ] + } + ], + "index": 18.5, + "virtual_lines": [ + { + "bbox": [ + 205, + 284, + 441, + 298.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 205, + 298.0, + 441, + 312.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 141, + 316, + 504, + 339 + ], + "lines": [ + { + "bbox": [ + 142, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 142, + 316, + 231, + 329 + ], + "score": 1.0, + "content": "Therefore, the larger", + "type": "text" + }, + { + "bbox": [ + 231, + 316, + 277, + 327 + ], + "score": 0.44, + "content": "( x \\bmod 2 ^ { m } )", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 316, + 505, + 329 + ], + "score": 1.0, + "content": ") is, the more likely the latter condition is true. Dalskov", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 327, + 397, + 340 + ], + "spans": [ + { + "bbox": [ + 142, + 327, + 397, + 340 + ], + "score": 1.0, + "content": "et al. [2020] present an efficient protocol in our security model.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 87, + 347, + 506, + 381 + ], + "lines": [ + { + "bbox": [ + 86, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 86, + 350, + 100, + 360 + ], + "score": 1.0, + "content": "142", + "type": "text" + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "Our quantization scheme is related to quantized neural networks (see e.g. Hubara et al. [2016]).", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 87, + 358, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 87, + 362, + 99, + 370 + ], + "score": 1.0, + "content": "143", + "type": "text" + }, + { + "bbox": [ + 104, + 358, + 505, + 372 + ], + "score": 1.0, + "content": "However, our consideration is not to compress the model, but to improve the computational speed", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 86, + 370, + 228, + 381 + ], + "spans": [ + { + "bbox": [ + 86, + 372, + 100, + 381 + ], + "score": 1.0, + "content": "144", + "type": "text" + }, + { + "bbox": [ + 105, + 370, + 228, + 381 + ], + "score": 1.0, + "content": "and save communication cost.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 86, + 393, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 86, + 393, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 86, + 396, + 100, + 405 + ], + "score": 1.0, + "content": "145", + "type": "text" + }, + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "score": 1.0, + "content": "Dot products Dot products are an essential building block of linear computation such as matrix", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 86, + 403, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 86, + 406, + 100, + 416 + ], + "score": 1.0, + "content": "146", + "type": "text" + }, + { + "bbox": [ + 105, + 403, + 506, + 418 + ], + "score": 1.0, + "content": "multiplication. In the light of quantization, it is possible to reduce the usage of truncation by deferring", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 86, + 416, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 86, + 418, + 99, + 426 + ], + "score": 1.0, + "content": "147", + "type": "text" + }, + { + "bbox": [ + 106, + 416, + 505, + 428 + ], + "score": 1.0, + "content": "after the summation. In other words, the dot product in the integer representations is computed before", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 86, + 427, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 86, + 429, + 100, + 438 + ], + "score": 1.0, + "content": "148", + "type": "text" + }, + { + "bbox": [ + 106, + 427, + 505, + 438 + ], + "score": 1.0, + "content": "truncating. This not only reduces the truncation error, it is also more efficient because the truncation", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 86, + 437, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 86, + 439, + 100, + 449 + ], + "score": 1.0, + "content": "149", + "type": "text" + }, + { + "bbox": [ + 104, + 437, + 506, + 450 + ], + "score": 1.0, + "content": "is the most expensive part in quantized secure multiplication. Similarly, our protocol allows to defer", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 86, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 86, + 450, + 100, + 460 + ], + "score": 1.0, + "content": "150", + "type": "text" + }, + { + "bbox": [ + 106, + 448, + 313, + 460 + ], + "score": 1.0, + "content": "the communication needed for multiplication. Let", + "type": "text" + }, + { + "bbox": [ + 313, + 449, + 320, + 458 + ], + "score": 0.81, + "content": "\\vec { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 448, + 338, + 460 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 339, + 448, + 346, + 460 + ], + "score": 0.85, + "content": "\\vec { y }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 448, + 505, + 460 + ], + "score": 1.0, + "content": "be two vectors where the elements are", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 86, + 458, + 496, + 477 + ], + "spans": [ + { + "bbox": [ + 86, + 464, + 99, + 473 + ], + "score": 1.0, + "content": "151", + "type": "text" + }, + { + "bbox": [ + 103, + 458, + 192, + 477 + ], + "score": 1.0, + "content": "secret shared, that is,", + "type": "text" + }, + { + "bbox": [ + 192, + 459, + 302, + 474 + ], + "score": 0.94, + "content": "\\{ x ^ { ( i ) } \\} = x _ { 0 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 459, + 372, + 476 + ], + "score": 1.0, + "content": "and similarly for", + "type": "text" + }, + { + "bbox": [ + 372, + 461, + 388, + 474 + ], + "score": 0.91, + "content": "\\boldsymbol y ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 459, + 496, + 476 + ], + "score": 1.0, + "content": ". The inner product then is", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28 + }, + { + "type": "interline_equation", + "bbox": [ + 127, + 479, + 483, + 561 + ], + "lines": [ + { + "bbox": [ + 127, + 479, + 483, + 561 + ], + "spans": [ + { + "bbox": [ + 127, + 479, + 483, + 561 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { \\displaystyle \\sum _ { i } x ^ { ( i ) } \\cdot y ^ { ( i ) } = \\sum _ { i } ( x _ { 0 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) } ) \\cdot ( y _ { 0 } ^ { ( i ) } + y _ { 1 } ^ { ( i ) } + y _ { 2 } ^ { ( i ) } ) } \\\\ & { \\quad \\quad \\quad \\quad = \\displaystyle \\sum _ { i } ( x _ { 0 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } + x _ { 0 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } ) + \\sum _ { i } ( x _ { 1 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } ) } \\\\ & { \\quad \\quad \\quad \\quad + \\displaystyle \\sum _ { i } ( x _ { 2 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } + x _ { 0 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } ) . } \\end{array}", + "type": "interline_equation", + "image_path": "36540aeb1a5d2f89955c3e16fde0f520a4fd1af5a546d08dd4d4fe06ee6c50ec.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 127, + 479, + 483, + 506.3333333333333 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 127, + 506.3333333333333, + 483, + 533.6666666666666 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 127, + 533.6666666666666, + 483, + 561.0 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "text", + "bbox": [ + 91, + 566, + 504, + 589 + ], + "lines": [ + { + "bbox": [ + 89, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 89, + 569, + 101, + 578 + ], + "score": 1.0, + "content": "152", + "type": "text" + }, + { + "bbox": [ + 104, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "The three sums in the last term can be compute locally by one party each before applying the same", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 87, + 578, + 261, + 590 + ], + "spans": [ + { + "bbox": [ + 87, + 578, + 261, + 590 + ], + "score": 1.0, + "content": "153 protocol as for a single multiplication.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 86, + 601, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 86, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 86, + 604, + 99, + 613 + ], + "score": 1.0, + "content": "154", + "type": "text" + }, + { + "bbox": [ + 106, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "Comparisons Arithmetic secret sharing does not allow to access the individual bits directly. It", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 86, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 86, + 614, + 99, + 624 + ], + "score": 1.0, + "content": "155", + "type": "text" + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "is therefore not straightforward to compute comparisons such as “less than”. There is a long line", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 86, + 622, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 86, + 626, + 99, + 635 + ], + "score": 1.0, + "content": "156", + "type": "text" + }, + { + "bbox": [ + 105, + 622, + 506, + 637 + ], + "score": 1.0, + "content": "of literature on how to achieve this going back to at least Damgård et al. [2006]. More recently,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 86, + 633, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 86, + 637, + 99, + 646 + ], + "score": 1.0, + "content": "157", + "type": "text" + }, + { + "bbox": [ + 105, + 633, + 506, + 648 + ], + "score": 1.0, + "content": "most attention has been given to combine the power of arithmetic and binary secret sharing in", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 86, + 644, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 86, + 648, + 99, + 657 + ], + "score": 1.0, + "content": "158", + "type": "text" + }, + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "score": 1.0, + "content": "order to combine the best of worlds. One possibility to do so is to plainly convert to the binary", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 86, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 86, + 658, + 99, + 668 + ], + "score": 1.0, + "content": "159", + "type": "text" + }, + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "domain and compute the comparison circuit there. In our concrete implementation we use the more", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 86, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 99, + 679 + ], + "score": 1.0, + "content": "160", + "type": "text" + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "efficient approach by Mohassel and Rindal [2018]. It starts by taking the difference of the two", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 86, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 99, + 690 + ], + "score": 1.0, + "content": "161", + "type": "text" + }, + { + "bbox": [ + 105, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "inputs. Computing the comparison then reduces to comparing to zero, which in turn is equivalent", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 86, + 687, + 506, + 704 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 99, + 700 + ], + "score": 1.0, + "content": "162", + "type": "text" + }, + { + "bbox": [ + 104, + 687, + 506, + 704 + ], + "score": 1.0, + "content": "to extracting the most significant bit as it indicates the sign. The latter is achieved by converting", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 86, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 99, + 711 + ], + "score": 1.0, + "content": "163", + "type": "text" + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "the shares locally to bit-wise sharing of the arithmetic shares, which sum up to the secret value. It", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 86, + 711, + 499, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 99, + 722 + ], + "score": 1.0, + "content": "164", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 499, + 724 + ], + "score": 1.0, + "content": "remains to compute the sum of the binary shares in order to come up with the most significant bit.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 42 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 86, + 161, + 101, + 286 + ], + "lines": [ + { + "bbox": [ + 85, + 162, + 100, + 173 + ], + "spans": [ + { + "bbox": [ + 85, + 162, + 100, + 173 + ], + "score": 1.0, + "content": "129", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 173, + 100, + 184 + ], + "spans": [ + { + "bbox": [ + 85, + 173, + 100, + 184 + ], + "score": 1.0, + "content": "130", + "type": "text" + } + ] + }, + { + "bbox": [ + 86, + 184, + 99, + 194 + ], + "spans": [ + { + "bbox": [ + 86, + 184, + 99, + 194 + ], + "score": 1.0, + "content": "131", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 195, + 100, + 207 + ], + "spans": [ + { + "bbox": [ + 85, + 195, + 100, + 207 + ], + "score": 1.0, + "content": "132", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 210, + 100, + 222 + ], + "spans": [ + { + "bbox": [ + 85, + 210, + 100, + 222 + ], + "score": 1.0, + "content": "133", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 221, + 100, + 233 + ], + "spans": [ + { + "bbox": [ + 85, + 221, + 100, + 233 + ], + "score": 1.0, + "content": "134", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 232, + 100, + 244 + ], + "spans": [ + { + "bbox": [ + 85, + 232, + 100, + 244 + ], + "score": 1.0, + "content": "135", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 243, + 100, + 254 + ], + "spans": [ + { + "bbox": [ + 85, + 243, + 100, + 254 + ], + "score": 1.0, + "content": "136", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 254, + 100, + 265 + ], + "spans": [ + { + "bbox": [ + 85, + 254, + 100, + 265 + ], + "score": 1.0, + "content": "137", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 265, + 100, + 276 + ], + "spans": [ + { + "bbox": [ + 85, + 265, + 100, + 276 + ], + "score": 1.0, + "content": "138", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 276, + 100, + 287 + ], + "spans": [ + { + "bbox": [ + 85, + 276, + 100, + 287 + ], + "score": 1.0, + "content": "139", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "index", + "bbox": [ + 87, + 72, + 505, + 150 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 86, + 73, + 506, + 151 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 134, + 159, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 133, + 158, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 133, + 158, + 353, + 173 + ], + "score": 1.0, + "content": "• An obvious correction would be to shift the result by", + "type": "text" + }, + { + "bbox": [ + 353, + 160, + 360, + 172 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 158, + 428, + 173 + ], + "score": 1.0, + "content": "bits after adding", + "type": "text" + }, + { + "bbox": [ + 428, + 159, + 450, + 170 + ], + "score": 0.91, + "content": "2 ^ { f - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 158, + 506, + 173 + ], + "score": 1.0, + "content": "to the integer", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 171, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 141, + 171, + 506, + 183 + ], + "score": 1.0, + "content": "representation. This ensures rounding to the nearest number possible in the representation,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 141, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "with the tie being broken by rounding up. Dalskov et al. [2021] presented an efficient", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 193, + 410, + 205 + ], + "spans": [ + { + "bbox": [ + 142, + 193, + 410, + 205 + ], + "score": 1.0, + "content": "implementation of the truncation using mixed-circuit computation.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 133, + 158, + 506, + 205 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 208, + 505, + 285 + ], + "lines": [ + { + "bbox": [ + 132, + 208, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 132, + 208, + 506, + 221 + ], + "score": 1.0, + "content": "• However, Catrina and Saxena have found that in the context of secure computation it is more", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 219, + 504, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 219, + 504, + 231 + ], + "score": 1.0, + "content": "efficient to use probabilistic truncation. This method rounds up or down probabilistically", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 230, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 505, + 243 + ], + "score": 1.0, + "content": "depending on the input. For example, probabilistically rounding 0.75 to an integer would", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 142, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 142, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "see it rounded of up with probability 0.75 and down with probability 0.25. The probabilistic", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 142, + 252, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 142, + 252, + 505, + 264 + ], + "score": 1.0, + "content": "truncation is an effect of the fact that the operation involves the truncation of a randomized", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 262, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 262, + 272, + 277 + ], + "score": 1.0, + "content": "value, that is the computation of", + "type": "text" + }, + { + "bbox": [ + 272, + 263, + 329, + 275 + ], + "score": 0.92, + "content": "\\left\\lfloor ( x + r ) / 2 ^ { m } \\right\\rfloor", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 262, + 383, + 277 + ], + "score": 1.0, + "content": "for a random", + "type": "text" + }, + { + "bbox": [ + 384, + 264, + 393, + 273 + ], + "score": 0.79, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 262, + 432, + 277 + ], + "score": 1.0, + "content": "-bit value", + "type": "text" + }, + { + "bbox": [ + 432, + 265, + 438, + 273 + ], + "score": 0.74, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 262, + 506, + 277 + ], + "score": 1.0, + "content": ". It is easy to see", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 273, + 162, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 162, + 286 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14, + "bbox_fs": [ + 132, + 208, + 506, + 286 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 205, + 284, + 441, + 312 + ], + "lines": [ + { + "bbox": [ + 205, + 284, + 441, + 312 + ], + "spans": [ + { + "bbox": [ + 205, + 284, + 441, + 312 + ], + "score": 0.92, + "content": "\\lfloor ( x + r ) / 2 ^ { m } \\rfloor = \\left\\{ \\begin{array} { l l } { \\lfloor x / 2 ^ { m } \\rfloor } & { ( x \\bmod 2 ^ { m } + r ) < 2 ^ { m } } \\\\ { \\lfloor x / 2 ^ { m } \\rfloor + 1 } & { ( x \\bmod 2 ^ { m } + r ) \\ge 2 ^ { m } . } \\end{array} \\right.", + "type": "interline_equation", + "image_path": "8c5c9712adea6b5b528c5e11a746ad687533c04d65eda8941ed882721c5e70cc.jpg" + } + ] + } + ], + "index": 18.5, + "virtual_lines": [ + { + "bbox": [ + 205, + 284, + 441, + 298.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 205, + 298.0, + 441, + 312.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 141, + 316, + 504, + 339 + ], + "lines": [ + { + "bbox": [ + 142, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 142, + 316, + 231, + 329 + ], + "score": 1.0, + "content": "Therefore, the larger", + "type": "text" + }, + { + "bbox": [ + 231, + 316, + 277, + 327 + ], + "score": 0.44, + "content": "( x \\bmod 2 ^ { m } )", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 316, + 505, + 329 + ], + "score": 1.0, + "content": ") is, the more likely the latter condition is true. Dalskov", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 327, + 397, + 340 + ], + "spans": [ + { + "bbox": [ + 142, + 327, + 397, + 340 + ], + "score": 1.0, + "content": "et al. [2020] present an efficient protocol in our security model.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 142, + 316, + 505, + 340 + ] + }, + { + "type": "index", + "bbox": [ + 87, + 347, + 506, + 381 + ], + "lines": [ + { + "bbox": [ + 86, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 86, + 350, + 100, + 360 + ], + "score": 1.0, + "content": "142", + "type": "text" + }, + { + "bbox": [ + 105, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "Our quantization scheme is related to quantized neural networks (see e.g. Hubara et al. [2016]).", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 87, + 358, + 505, + 372 + ], + "spans": [ + { + "bbox": [ + 87, + 362, + 99, + 370 + ], + "score": 1.0, + "content": "143", + "type": "text" + }, + { + "bbox": [ + 104, + 358, + 505, + 372 + ], + "score": 1.0, + "content": "However, our consideration is not to compress the model, but to improve the computational speed", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 370, + 228, + 381 + ], + "spans": [ + { + "bbox": [ + 86, + 372, + 100, + 381 + ], + "score": 1.0, + "content": "144", + "type": "text" + }, + { + "bbox": [ + 105, + 370, + 228, + 381 + ], + "score": 1.0, + "content": "and save communication cost.", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 393, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 86, + 396, + 100, + 405 + ], + "score": 1.0, + "content": "145", + "type": "text" + }, + { + "bbox": [ + 104, + 393, + 506, + 406 + ], + "score": 1.0, + "content": "Dot products Dot products are an essential building block of linear computation such as matrix", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 403, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 86, + 406, + 100, + 416 + ], + "score": 1.0, + "content": "146", + "type": "text" + }, + { + "bbox": [ + 105, + 403, + 506, + 418 + ], + "score": 1.0, + "content": "multiplication. In the light of quantization, it is possible to reduce the usage of truncation by deferring", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 416, + 505, + 428 + ], + "spans": [ + { + "bbox": [ + 86, + 418, + 99, + 426 + ], + "score": 1.0, + "content": "147", + "type": "text" + }, + { + "bbox": [ + 106, + 416, + 505, + 428 + ], + "score": 1.0, + "content": "after the summation. In other words, the dot product in the integer representations is computed before", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 427, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 86, + 429, + 100, + 438 + ], + "score": 1.0, + "content": "148", + "type": "text" + }, + { + "bbox": [ + 106, + 427, + 505, + 438 + ], + "score": 1.0, + "content": "truncating. This not only reduces the truncation error, it is also more efficient because the truncation", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 437, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 86, + 439, + 100, + 449 + ], + "score": 1.0, + "content": "149", + "type": "text" + }, + { + "bbox": [ + 104, + 437, + 506, + 450 + ], + "score": 1.0, + "content": "is the most expensive part in quantized secure multiplication. Similarly, our protocol allows to defer", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 86, + 450, + 100, + 460 + ], + "score": 1.0, + "content": "150", + "type": "text" + }, + { + "bbox": [ + 106, + 448, + 313, + 460 + ], + "score": 1.0, + "content": "the communication needed for multiplication. Let", + "type": "text" + }, + { + "bbox": [ + 313, + 449, + 320, + 458 + ], + "score": 0.81, + "content": "\\vec { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 448, + 338, + 460 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 339, + 448, + 346, + 460 + ], + "score": 0.85, + "content": "\\vec { y }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 448, + 505, + 460 + ], + "score": 1.0, + "content": "be two vectors where the elements are", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 458, + 496, + 477 + ], + "spans": [ + { + "bbox": [ + 86, + 464, + 99, + 473 + ], + "score": 1.0, + "content": "151", + "type": "text" + }, + { + "bbox": [ + 103, + 458, + 192, + 477 + ], + "score": 1.0, + "content": "secret shared, that is,", + "type": "text" + }, + { + "bbox": [ + 192, + 459, + 302, + 474 + ], + "score": 0.94, + "content": "\\{ x ^ { ( i ) } \\} = x _ { 0 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 459, + 372, + 476 + ], + "score": 1.0, + "content": "and similarly for", + "type": "text" + }, + { + "bbox": [ + 372, + 461, + 388, + 474 + ], + "score": 0.91, + "content": "\\boldsymbol y ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 459, + 496, + 476 + ], + "score": 1.0, + "content": ". The inner product then is", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + } + ], + "index": 23, + "bbox_fs": [ + 86, + 347, + 506, + 381 + ] + }, + { + "type": "index", + "bbox": [ + 86, + 393, + 505, + 475 + ], + "lines": [], + "index": 28, + "bbox_fs": [ + 86, + 393, + 506, + 477 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 127, + 479, + 483, + 561 + ], + "lines": [ + { + "bbox": [ + 127, + 479, + 483, + 561 + ], + "spans": [ + { + "bbox": [ + 127, + 479, + 483, + 561 + ], + "score": 0.94, + "content": "\\begin{array} { r l } & { \\displaystyle \\sum _ { i } x ^ { ( i ) } \\cdot y ^ { ( i ) } = \\sum _ { i } ( x _ { 0 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) } ) \\cdot ( y _ { 0 } ^ { ( i ) } + y _ { 1 } ^ { ( i ) } + y _ { 2 } ^ { ( i ) } ) } \\\\ & { \\quad \\quad \\quad \\quad = \\displaystyle \\sum _ { i } ( x _ { 0 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } + x _ { 0 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } ) + \\sum _ { i } ( x _ { 1 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } + x _ { 1 } ^ { ( i ) } y _ { 1 } ^ { ( i ) } ) } \\\\ & { \\quad \\quad \\quad \\quad + \\displaystyle \\sum _ { i } ( x _ { 2 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } + x _ { 2 } ^ { ( i ) } y _ { 0 } ^ { ( i ) } + x _ { 0 } ^ { ( i ) } y _ { 2 } ^ { ( i ) } ) . } \\end{array}", + "type": "interline_equation", + "image_path": "36540aeb1a5d2f89955c3e16fde0f520a4fd1af5a546d08dd4d4fe06ee6c50ec.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 127, + 479, + 483, + 506.3333333333333 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 127, + 506.3333333333333, + 483, + 533.6666666666666 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 127, + 533.6666666666666, + 483, + 561.0 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "index", + "bbox": [ + 91, + 566, + 504, + 589 + ], + "lines": [ + { + "bbox": [ + 89, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 89, + 569, + 101, + 578 + ], + "score": 1.0, + "content": "152", + "type": "text" + }, + { + "bbox": [ + 104, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "The three sums in the last term can be compute locally by one party each before applying the same", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 87, + 578, + 261, + 590 + ], + "spans": [ + { + "bbox": [ + 87, + 578, + 261, + 590 + ], + "score": 1.0, + "content": "153 protocol as for a single multiplication.", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 86, + 604, + 99, + 613 + ], + "score": 1.0, + "content": "154", + "type": "text" + }, + { + "bbox": [ + 106, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "Comparisons Arithmetic secret sharing does not allow to access the individual bits directly. It", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 86, + 614, + 99, + 624 + ], + "score": 1.0, + "content": "155", + "type": "text" + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "is therefore not straightforward to compute comparisons such as “less than”. There is a long line", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 622, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 86, + 626, + 99, + 635 + ], + "score": 1.0, + "content": "156", + "type": "text" + }, + { + "bbox": [ + 105, + 622, + 506, + 637 + ], + "score": 1.0, + "content": "of literature on how to achieve this going back to at least Damgård et al. [2006]. More recently,", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 633, + 506, + 648 + ], + "spans": [ + { + "bbox": [ + 86, + 637, + 99, + 646 + ], + "score": 1.0, + "content": "157", + "type": "text" + }, + { + "bbox": [ + 105, + 633, + 506, + 648 + ], + "score": 1.0, + "content": "most attention has been given to combine the power of arithmetic and binary secret sharing in", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 644, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 86, + 648, + 99, + 657 + ], + "score": 1.0, + "content": "158", + "type": "text" + }, + { + "bbox": [ + 105, + 644, + 506, + 659 + ], + "score": 1.0, + "content": "order to combine the best of worlds. One possibility to do so is to plainly convert to the binary", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 86, + 658, + 99, + 668 + ], + "score": 1.0, + "content": "159", + "type": "text" + }, + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "domain and compute the comparison circuit there. In our concrete implementation we use the more", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 99, + 679 + ], + "score": 1.0, + "content": "160", + "type": "text" + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "efficient approach by Mohassel and Rindal [2018]. It starts by taking the difference of the two", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 678, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 99, + 690 + ], + "score": 1.0, + "content": "161", + "type": "text" + }, + { + "bbox": [ + 105, + 678, + 505, + 691 + ], + "score": 1.0, + "content": "inputs. Computing the comparison then reduces to comparing to zero, which in turn is equivalent", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 687, + 506, + 704 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 99, + 700 + ], + "score": 1.0, + "content": "162", + "type": "text" + }, + { + "bbox": [ + 104, + 687, + 506, + 704 + ], + "score": 1.0, + "content": "to extracting the most significant bit as it indicates the sign. The latter is achieved by converting", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 99, + 711 + ], + "score": 1.0, + "content": "163", + "type": "text" + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "the shares locally to bit-wise sharing of the arithmetic shares, which sum up to the secret value. It", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 711, + 499, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 99, + 722 + ], + "score": 1.0, + "content": "164", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 499, + 724 + ], + "score": 1.0, + "content": "remains to compute the sum of the binary shares in order to come up with the most significant bit.", + "type": "text" + } + ], + "index": 47, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 99, + 84 + ], + "score": 1.0, + "content": "165", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "Oblivious Selection Plain secure computation does not allow branching because the parties would", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 82, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 85, + 85, + 100, + 96 + ], + "score": 1.0, + "content": "166", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "score": 1.0, + "content": "need to be aware which branch is followed. Conditional assignment can be implemented as follows", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 86, + 96, + 99, + 106 + ], + "score": 1.0, + "content": "167", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 94, + 155, + 107 + ], + "score": 1.0, + "content": "however. If", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 155, + 94, + 197, + 106 + ], + "score": 0.94, + "content": "b \\in \\{ 0 , 1 \\}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 197, + 94, + 290, + 107 + ], + "score": 1.0, + "content": "denotes the condition,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 290, + 95, + 351, + 106 + ], + "score": 0.93, + "content": "x + b \\cdot ( y - x )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 351, + 94, + 387, + 107 + ], + "score": 1.0, + "content": "is either", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 387, + 96, + 394, + 104 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 394, + 94, + 406, + 107 + ], + "score": 1.0, + "content": "or", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 406, + 96, + 413, + 106 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 414, + 94, + 471, + 107 + ], + "score": 1.0, + "content": "depending on", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 471, + 95, + 477, + 104 + ], + "score": 0.55, + "content": "b", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 477, + 94, + 505, + 107 + ], + "score": 1.0, + "content": ". If the", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 86, + 108, + 100, + 117 + ], + "score": 1.0, + "content": "168", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 105, + 309, + 118 + ], + "score": 1.0, + "content": "condition is available in binary secret sharing but", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 309, + 108, + 317, + 115 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 317, + 105, + 335, + 118 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 335, + 108, + 342, + 117 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 342, + 105, + 459, + 118 + ], + "score": 1.0, + "content": "in arithmetic secret sharing,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 459, + 106, + 465, + 115 + ], + "score": 0.67, + "content": "b", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 465, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "has to be", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 85, + 118, + 100, + 129 + ], + "score": 1.0, + "content": "169", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "converted to the latter. This can be done using a daBit as introduced by Rotaru and Wood [2019],", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 127, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 86, + 129, + 99, + 139 + ], + "score": 1.0, + "content": "170", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "score": 1.0, + "content": "which is a secret random bit shared both in arithmetic and binary. It allows to mask a bit in one world", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 138, + 458, + 150 + ], + "spans": [ + { + "bbox": [ + 86, + 140, + 99, + 149 + ], + "score": 1.0, + "content": "171", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 138, + 458, + 150 + ], + "score": 1.0, + "content": "by XORing it. The result is then revealed and the masking is undone in the other world.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 86, + 163, + 100, + 172 + ], + "score": 1.0, + "content": "172", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "Division Catrina and Saxena [2010] have shown how to implement quantized division using the", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 172, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 86, + 174, + 100, + 184 + ], + "score": 1.0, + "content": "173", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "score": 1.0, + "content": "algorithm by Goldschmidt [1964]. It mainly uses arithmetic and the probabilistic truncation already", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 183, + 507, + 196 + ], + "spans": [ + { + "bbox": [ + 86, + 186, + 100, + 194 + ], + "score": 1.0, + "content": "174", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 183, + 507, + 196 + ], + "score": 1.0, + "content": "explained. In addition, the initial approximation requires a full bit decomposition as described above.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 193, + 507, + 207 + ], + "spans": [ + { + "bbox": [ + 86, + 196, + 100, + 206 + ], + "score": 1.0, + "content": "175", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 193, + 507, + 207 + ], + "score": 1.0, + "content": "The error of the output depends on the error in the multiplications used for Goldschmidt’s iteration,", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 205, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 86, + 207, + 100, + 216 + ], + "score": 1.0, + "content": "176", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 205, + 506, + 218 + ], + "score": 1.0, + "content": "which compounds in particular when using probabilistic truncation. Due to the nature of secure", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 216, + 505, + 229 + ], + "spans": [ + { + "bbox": [ + 85, + 218, + 100, + 228 + ], + "score": 1.0, + "content": "177", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 216, + 505, + 229 + ], + "score": 1.0, + "content": "computation, the result of division by zero is undefined. One could obtain a secret failure bit by", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 227, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 85, + 228, + 100, + 239 + ], + "score": 1.0, + "content": "178", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 227, + 506, + 239 + ], + "score": 1.0, + "content": "testing the divisor to zero. However, we found that not to be necessary in our algorithm. This is", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 237, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 85, + 239, + 100, + 250 + ], + "score": 1.0, + "content": "179", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 237, + 506, + 250 + ], + "score": 1.0, + "content": "because we only use division by secret value only for the softmax function where the it is guaranteed", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 249, + 183, + 261 + ], + "spans": [ + { + "bbox": [ + 86, + 251, + 100, + 260 + ], + "score": 1.0, + "content": "180", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 249, + 183, + 261 + ], + "score": 1.0, + "content": "to strictly positive.", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 86, + 273, + 99, + 283 + ], + "score": 1.0, + "content": "181", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "Logarithm Computation logarithm with any public base can be reduced to logarithm to base two", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 86, + 284, + 100, + 294 + ], + "score": 1.0, + "content": "182", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 282, + 132, + 295 + ], + "score": 1.0, + "content": "using", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 132, + 283, + 228, + 294 + ], + "score": 0.85, + "content": "\\log _ { x } y = \\log _ { 2 } y \\cdot \\log _ { x } 2", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 228, + 282, + 433, + 295 + ], + "score": 1.0, + "content": ". Aly and Smart [2019] have proposed computing", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 433, + 282, + 476, + 294 + ], + "score": 0.92, + "content": "y = a \\cdot 2 ^ { b }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 477, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "where", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 86, + 295, + 100, + 306 + ], + "score": 1.0, + "content": "183", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 294, + 153, + 305 + ], + "score": 0.88, + "content": "a \\in [ 0 . 5 , 1 )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 154, + 293, + 172, + 306 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 172, + 294, + 196, + 304 + ], + "score": 0.89, + "content": "b \\in \\mathbb { Z }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 197, + 293, + 316, + 306 + ], + "score": 1.0, + "content": ". This then allows to compute", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 316, + 294, + 396, + 305 + ], + "score": 0.91, + "content": "\\log _ { 2 } y = \\log _ { 2 } a + b", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 396, + 293, + 505, + 306 + ], + "score": 1.0, + "content": ". Given the restricted range", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 303, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 86, + 306, + 100, + 316 + ], + "score": 1.0, + "content": "184", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 303, + 117, + 317 + ], + "score": 1.0, + "content": "of", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 117, + 307, + 123, + 315 + ], + "score": 0.53, + "content": "a", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 124, + 303, + 127, + 317 + ], + "score": 1.0, + "content": ",", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 127, + 306, + 153, + 316 + ], + "score": 0.77, + "content": "\\log _ { 2 } a", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 153, + 303, + 505, + 317 + ], + "score": 1.0, + "content": "can be approximated using a division of polynomials. Numerical stability and input range", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 315, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 86, + 317, + 100, + 326 + ], + "score": 1.0, + "content": "185", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "score": 1.0, + "content": "control are less of an issue here because we only use logarithm for the loss computation, which does", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 326, + 211, + 339 + ], + "spans": [ + { + "bbox": [ + 86, + 328, + 100, + 338 + ], + "score": 1.0, + "content": "186", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 326, + 211, + 339 + ], + "score": 1.0, + "content": "not influence the training.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 347, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 86, + 351, + 100, + 361 + ], + "score": 1.0, + "content": "187", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 347, + 222, + 362 + ], + "score": 1.0, + "content": "Exponentiation By using", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 222, + 348, + 280, + 360 + ], + "score": 0.92, + "content": "x ^ { y } = 2 ^ { y \\log _ { 2 } x }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 280, + 347, + 506, + 362 + ], + "score": 1.0, + "content": ", any exponentiation can be reduced to exponentiation", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 358, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 86, + 363, + 100, + 372 + ], + "score": 1.0, + "content": "188", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 358, + 370, + 375 + ], + "score": 1.0, + "content": "with base two. Aly and Smart [2019] have shown how to compute", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 371, + 360, + 446, + 371 + ], + "score": 0.9, + "content": "2 ^ { a } = 2 ^ { \\lfloor a \\rfloor } \\cdot 2 ^ { a - \\lfloor a \\rfloor }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 446, + 358, + 506, + 375 + ], + "score": 1.0, + "content": "by computing", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 372, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 86, + 374, + 100, + 384 + ], + "score": 1.0, + "content": "189", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 372, + 506, + 385 + ], + "score": 1.0, + "content": "the two exponents using bit decomposition and the second factor using a polynomial approximation.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 382, + 402, + 397 + ], + "spans": [ + { + "bbox": [ + 86, + 385, + 100, + 395 + ], + "score": 1.0, + "content": "190", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 382, + 219, + 397 + ], + "score": 1.0, + "content": "Regarding the first factor, if", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 219, + 383, + 279, + 397 + ], + "score": 0.94, + "content": "\\begin{array} { r } { b = \\sum _ { i \\geq 0 } b _ { i } 2 ^ { i } } \\end{array}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 280, + 382, + 352, + 397 + ], + "score": 1.0, + "content": "is an integer with", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 352, + 383, + 397, + 395 + ], + "score": 0.93, + "content": "b _ { i } \\in \\{ 0 , 1 \\}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 397, + 382, + 402, + 397 + ], + "score": 1.0, + "content": ",", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + } + ], + "index": 35.5, + "bbox_fs": [ + 87, + 566, + 505, + 590 + ] + }, + { + "type": "index", + "bbox": [ + 86, + 601, + 505, + 722 + ], + "lines": [], + "index": 42, + "bbox_fs": [ + 86, + 602, + 506, + 724 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 87, + 72, + 505, + 150 + ], + "lines": [ + { + "bbox": [ + 86, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 99, + 84 + ], + "score": 1.0, + "content": "165", + "type": "text" + }, + { + "bbox": [ + 106, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "Oblivious Selection Plain secure computation does not allow branching because the parties would", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 85, + 82, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 85, + 85, + 100, + 96 + ], + "score": 1.0, + "content": "166", + "type": "text" + }, + { + "bbox": [ + 105, + 82, + 506, + 97 + ], + "score": 1.0, + "content": "need to be aware which branch is followed. Conditional assignment can be implemented as follows", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 86, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 86, + 96, + 99, + 106 + ], + "score": 1.0, + "content": "167", + "type": "text" + }, + { + "bbox": [ + 106, + 94, + 155, + 107 + ], + "score": 1.0, + "content": "however. If", + "type": "text" + }, + { + "bbox": [ + 155, + 94, + 197, + 106 + ], + "score": 0.94, + "content": "b \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 94, + 290, + 107 + ], + "score": 1.0, + "content": "denotes the condition,", + "type": "text" + }, + { + "bbox": [ + 290, + 95, + 351, + 106 + ], + "score": 0.93, + "content": "x + b \\cdot ( y - x )", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 94, + 387, + 107 + ], + "score": 1.0, + "content": "is either", + "type": "text" + }, + { + "bbox": [ + 387, + 96, + 394, + 104 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 94, + 406, + 107 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 406, + 96, + 413, + 106 + ], + "score": 0.78, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 94, + 471, + 107 + ], + "score": 1.0, + "content": "depending on", + "type": "text" + }, + { + "bbox": [ + 471, + 95, + 477, + 104 + ], + "score": 0.55, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 94, + 505, + 107 + ], + "score": 1.0, + "content": ". If the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 86, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 86, + 108, + 100, + 117 + ], + "score": 1.0, + "content": "168", + "type": "text" + }, + { + "bbox": [ + 106, + 105, + 309, + 118 + ], + "score": 1.0, + "content": "condition is available in binary secret sharing but", + "type": "text" + }, + { + "bbox": [ + 309, + 108, + 317, + 115 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 105, + 335, + 118 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 335, + 108, + 342, + 117 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 105, + 459, + 118 + ], + "score": 1.0, + "content": "in arithmetic secret sharing,", + "type": "text" + }, + { + "bbox": [ + 459, + 106, + 465, + 115 + ], + "score": 0.67, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "has to be", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 85, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 85, + 118, + 100, + 129 + ], + "score": 1.0, + "content": "169", + "type": "text" + }, + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "converted to the latter. This can be done using a daBit as introduced by Rotaru and Wood [2019],", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 86, + 127, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 86, + 129, + 99, + 139 + ], + "score": 1.0, + "content": "170", + "type": "text" + }, + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "score": 1.0, + "content": "which is a secret random bit shared both in arithmetic and binary. It allows to mask a bit in one world", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 86, + 138, + 458, + 150 + ], + "spans": [ + { + "bbox": [ + 86, + 140, + 99, + 149 + ], + "score": 1.0, + "content": "171", + "type": "text" + }, + { + "bbox": [ + 106, + 138, + 458, + 150 + ], + "score": 1.0, + "content": "by XORing it. The result is then revealed and the masking is undone in the other world.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 86, + 161, + 505, + 260 + ], + "lines": [ + { + "bbox": [ + 86, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 86, + 163, + 100, + 172 + ], + "score": 1.0, + "content": "172", + "type": "text" + }, + { + "bbox": [ + 104, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "Division Catrina and Saxena [2010] have shown how to implement quantized division using the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 86, + 172, + 506, + 185 + ], + "spans": [ + { + "bbox": [ + 86, + 174, + 100, + 184 + ], + "score": 1.0, + "content": "173", + "type": "text" + }, + { + "bbox": [ + 105, + 172, + 506, + 185 + ], + "score": 1.0, + "content": "algorithm by Goldschmidt [1964]. It mainly uses arithmetic and the probabilistic truncation already", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 86, + 183, + 507, + 196 + ], + "spans": [ + { + "bbox": [ + 86, + 186, + 100, + 194 + ], + "score": 1.0, + "content": "174", + "type": "text" + }, + { + "bbox": [ + 105, + 183, + 507, + 196 + ], + "score": 1.0, + "content": "explained. In addition, the initial approximation requires a full bit decomposition as described above.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 86, + 193, + 507, + 207 + ], + "spans": [ + { + "bbox": [ + 86, + 196, + 100, + 206 + ], + "score": 1.0, + "content": "175", + "type": "text" + }, + { + "bbox": [ + 105, + 193, + 507, + 207 + ], + "score": 1.0, + "content": "The error of the output depends on the error in the multiplications used for Goldschmidt’s iteration,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 86, + 205, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 86, + 207, + 100, + 216 + ], + "score": 1.0, + "content": "176", + "type": "text" + }, + { + "bbox": [ + 105, + 205, + 506, + 218 + ], + "score": 1.0, + "content": "which compounds in particular when using probabilistic truncation. Due to the nature of secure", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 85, + 216, + 505, + 229 + ], + "spans": [ + { + "bbox": [ + 85, + 218, + 100, + 228 + ], + "score": 1.0, + "content": "177", + "type": "text" + }, + { + "bbox": [ + 105, + 216, + 505, + 229 + ], + "score": 1.0, + "content": "computation, the result of division by zero is undefined. One could obtain a secret failure bit by", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 85, + 227, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 85, + 228, + 100, + 239 + ], + "score": 1.0, + "content": "178", + "type": "text" + }, + { + "bbox": [ + 106, + 227, + 506, + 239 + ], + "score": 1.0, + "content": "testing the divisor to zero. However, we found that not to be necessary in our algorithm. This is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 85, + 237, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 85, + 239, + 100, + 250 + ], + "score": 1.0, + "content": "179", + "type": "text" + }, + { + "bbox": [ + 105, + 237, + 506, + 250 + ], + "score": 1.0, + "content": "because we only use division by secret value only for the softmax function where the it is guaranteed", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 86, + 249, + 183, + 261 + ], + "spans": [ + { + "bbox": [ + 86, + 251, + 100, + 260 + ], + "score": 1.0, + "content": "180", + "type": "text" + }, + { + "bbox": [ + 105, + 249, + 183, + 261 + ], + "score": 1.0, + "content": "to strictly positive.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 86, + 271, + 505, + 338 + ], + "lines": [ + { + "bbox": [ + 86, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 86, + 273, + 99, + 283 + ], + "score": 1.0, + "content": "181", + "type": "text" + }, + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "Logarithm Computation logarithm with any public base can be reduced to logarithm to base two", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 86, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 86, + 284, + 100, + 294 + ], + "score": 1.0, + "content": "182", + "type": "text" + }, + { + "bbox": [ + 104, + 282, + 132, + 295 + ], + "score": 1.0, + "content": "using", + "type": "text" + }, + { + "bbox": [ + 132, + 283, + 228, + 294 + ], + "score": 0.85, + "content": "\\log _ { x } y = \\log _ { 2 } y \\cdot \\log _ { x } 2", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 282, + 433, + 295 + ], + "score": 1.0, + "content": ". Aly and Smart [2019] have proposed computing", + "type": "text" + }, + { + "bbox": [ + 433, + 282, + 476, + 294 + ], + "score": 0.92, + "content": "y = a \\cdot 2 ^ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 86, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 86, + 295, + 100, + 306 + ], + "score": 1.0, + "content": "183", + "type": "text" + }, + { + "bbox": [ + 106, + 294, + 153, + 305 + ], + "score": 0.88, + "content": "a \\in [ 0 . 5 , 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 293, + 172, + 306 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 172, + 294, + 196, + 304 + ], + "score": 0.89, + "content": "b \\in \\mathbb { Z }", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 293, + 316, + 306 + ], + "score": 1.0, + "content": ". This then allows to compute", + "type": "text" + }, + { + "bbox": [ + 316, + 294, + 396, + 305 + ], + "score": 0.91, + "content": "\\log _ { 2 } y = \\log _ { 2 } a + b", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 293, + 505, + 306 + ], + "score": 1.0, + "content": ". Given the restricted range", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 86, + 303, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 86, + 306, + 100, + 316 + ], + "score": 1.0, + "content": "184", + "type": "text" + }, + { + "bbox": [ + 105, + 303, + 117, + 317 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 117, + 307, + 123, + 315 + ], + "score": 0.53, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 124, + 303, + 127, + 317 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 127, + 306, + 153, + 316 + ], + "score": 0.77, + "content": "\\log _ { 2 } a", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 303, + 505, + 317 + ], + "score": 1.0, + "content": "can be approximated using a division of polynomials. Numerical stability and input range", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 86, + 315, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 86, + 317, + 100, + 326 + ], + "score": 1.0, + "content": "185", + "type": "text" + }, + { + "bbox": [ + 105, + 315, + 506, + 328 + ], + "score": 1.0, + "content": "control are less of an issue here because we only use logarithm for the loss computation, which does", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 86, + 326, + 211, + 339 + ], + "spans": [ + { + "bbox": [ + 86, + 328, + 100, + 338 + ], + "score": 1.0, + "content": "186", + "type": "text" + }, + { + "bbox": [ + 105, + 326, + 211, + 339 + ], + "score": 1.0, + "content": "not influence the training.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 87, + 348, + 506, + 396 + ], + "lines": [ + { + "bbox": [ + 86, + 347, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 86, + 351, + 100, + 361 + ], + "score": 1.0, + "content": "187", + "type": "text" + }, + { + "bbox": [ + 105, + 347, + 222, + 362 + ], + "score": 1.0, + "content": "Exponentiation By using", + "type": "text" + }, + { + "bbox": [ + 222, + 348, + 280, + 360 + ], + "score": 0.92, + "content": "x ^ { y } = 2 ^ { y \\log _ { 2 } x }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 347, + 506, + 362 + ], + "score": 1.0, + "content": ", any exponentiation can be reduced to exponentiation", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 86, + 358, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 86, + 363, + 100, + 372 + ], + "score": 1.0, + "content": "188", + "type": "text" + }, + { + "bbox": [ + 104, + 358, + 370, + 375 + ], + "score": 1.0, + "content": "with base two. Aly and Smart [2019] have shown how to compute", + "type": "text" + }, + { + "bbox": [ + 371, + 360, + 446, + 371 + ], + "score": 0.9, + "content": "2 ^ { a } = 2 ^ { \\lfloor a \\rfloor } \\cdot 2 ^ { a - \\lfloor a \\rfloor }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 358, + 506, + 375 + ], + "score": 1.0, + "content": "by computing", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 86, + 372, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 86, + 374, + 100, + 384 + ], + "score": 1.0, + "content": "189", + "type": "text" + }, + { + "bbox": [ + 106, + 372, + 506, + 385 + ], + "score": 1.0, + "content": "the two exponents using bit decomposition and the second factor using a polynomial approximation.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 86, + 382, + 402, + 397 + ], + "spans": [ + { + "bbox": [ + 86, + 385, + 100, + 395 + ], + "score": 1.0, + "content": "190", + "type": "text" + }, + { + "bbox": [ + 104, + 382, + 219, + 397 + ], + "score": 1.0, + "content": "Regarding the first factor, if", + "type": "text" + }, + { + "bbox": [ + 219, + 383, + 279, + 397 + ], + "score": 0.94, + "content": "\\begin{array} { r } { b = \\sum _ { i \\geq 0 } b _ { i } 2 ^ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 382, + 352, + 397 + ], + "score": 1.0, + "content": "is an integer with", + "type": "text" + }, + { + "bbox": [ + 352, + 383, + 397, + 395 + ], + "score": 0.93, + "content": "b _ { i } \\in \\{ 0 , 1 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 382, + 402, + 397 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "interline_equation", + "bbox": [ + 196, + 401, + 415, + 430 + ], + "lines": [ + { + "bbox": [ + 196, + 401, + 415, + 430 + ], + "spans": [ + { + "bbox": [ + 196, + 401, + 415, + 430 + ], + "score": 0.91, + "content": "2 ^ { b } = 2 ^ { \\sum _ { i \\geq 0 } b _ { i } 2 ^ { i } } = \\prod _ { i \\geq 0 } 2 ^ { b _ { i } 2 ^ { i } } = \\prod _ { i \\geq 0 } ( 1 + b _ { i } \\cdot ( 2 ^ { 2 ^ { i } } - 1 ) ) .", + "type": "interline_equation", + "image_path": "8c23276368b1b8c7d81c896fefea584c2c7d3d49e6ccd58490eca1b2a9f47135.jpg" + } + ] + } + ], + "index": 26.5, + "virtual_lines": [ + { + "bbox": [ + 196, + 401, + 415, + 415.5 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 196, + 415.5, + 415, + 430.0 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 92, + 434, + 465, + 447 + ], + "lines": [ + { + "bbox": [ + 88, + 434, + 467, + 448 + ], + "spans": [ + { + "bbox": [ + 88, + 434, + 467, + 448 + ], + "score": 1.0, + "content": "191 As with division the numerical stability depends on the truncation used for multiplication.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 100, + 457, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 507, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 507, + 471 + ], + "score": 1.0, + "content": "Inverse square root Aly and Smart [2019] have proposed to compute square root using Gold-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "score": 1.0, + "content": "schmidt and Raphson-Newton iterations. We could combine this with the division above. However, Lu", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 480, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 492 + ], + "score": 1.0, + "content": "et al. [2020] have proposed a more direct computation that avoids running two successive iterations.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 105, + 502, + 505, + 570 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 446, + 515 + ], + "score": 1.0, + "content": "Uniformly random fractional number Limiting ourselves to intervals of the form", + "type": "text" + }, + { + "bbox": [ + 446, + 503, + 490, + 515 + ], + "score": 0.92, + "content": "[ x , x + 2 ^ { e } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 502, + 506, + 515 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 514, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 222, + 526 + ], + "score": 1.0, + "content": "a potentially negative integer", + "type": "text" + }, + { + "bbox": [ + 223, + 516, + 228, + 524 + ], + "score": 0.53, + "content": "e", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 514, + 426, + 526 + ], + "score": 1.0, + "content": ", we can reduce the problem to generate a random", + "type": "text" + }, + { + "bbox": [ + 427, + 514, + 457, + 525 + ], + "score": 0.92, + "content": "( f + { \\dot { e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 514, + 506, + 526 + ], + "score": 1.0, + "content": "-bit number", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 524, + 502, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 133, + 538 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 526, + 141, + 537 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 524, + 443, + 538 + ], + "score": 1.0, + "content": "is the fixed-point precision. Recall that we represent a fractional number", + "type": "text" + }, + { + "bbox": [ + 443, + 528, + 451, + 536 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 524, + 464, + 538 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 464, + 525, + 502, + 538 + ], + "score": 0.93, + "content": "\\lfloor x \\cdot 2 ^ { - f } \\rceil", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 537, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 193, + 549 + ], + "score": 1.0, + "content": "Generating a random", + "type": "text" + }, + { + "bbox": [ + 193, + 539, + 200, + 547 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 537, + 505, + 549 + ], + "score": 1.0, + "content": "-bit number is straight-forward using random bits, which in our protocol can", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "score": 1.0, + "content": "be generated as presented by Damgård et al. [2019]. In the context of our protocol however, Dalskov", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 559, + 493, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 493, + 570 + ], + "score": 1.0, + "content": "et al. [2021] have a presented a more efficient approach that involves mixed-circuit computation.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 105, + 581, + 505, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "Communication cost Table 1 show the total communication cost of some of the building blocks", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 590, + 507, + 606 + ], + "spans": [ + { + "bbox": [ + 104, + 590, + 184, + 606 + ], + "score": 1.0, + "content": "in our protocol for", + "type": "text" + }, + { + "bbox": [ + 184, + 593, + 215, + 604 + ], + "score": 0.9, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 590, + 363, + 606 + ], + "score": 1.0, + "content": ". This setting mandates the modulus", + "type": "text" + }, + { + "bbox": [ + 364, + 592, + 382, + 603 + ], + "score": 0.86, + "content": "2 ^ { 1 2 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 590, + 507, + 606 + ], + "score": 1.0, + "content": "because the division protocol", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 603, + 198, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 181, + 616 + ], + "score": 1.0, + "content": "requires bit length", + "type": "text" + }, + { + "bbox": [ + 182, + 604, + 194, + 615 + ], + "score": 0.86, + "content": "4 f", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 603, + 198, + 616 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "title", + "bbox": [ + 101, + 630, + 304, + 644 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 306, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 306, + 647 + ], + "score": 1.0, + "content": "4 Machine Learning Building Blocks", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 504, + 677 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "In this section, we will use the building blocks in Section 3 to construct high-level computational", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 664, + 216, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 216, + 679 + ], + "score": 1.0, + "content": "modules for deep learning.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 106, + 689, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Fully connected layers Both forward and back-propagation of fully connected layers can be seen", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "as matrix multiplications and thus can be implemented using dot products. A particular challenge in", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "secure computation is to compute a number of outputs in parallel in order to save communication", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "index", + "bbox": [ + 87, + 72, + 505, + 150 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 85, + 72, + 506, + 150 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 86, + 161, + 505, + 260 + ], + "lines": [], + "index": 11, + "bbox_fs": [ + 85, + 160, + 507, + 261 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 86, + 271, + 505, + 338 + ], + "lines": [], + "index": 18.5, + "bbox_fs": [ + 86, + 271, + 506, + 339 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 87, + 348, + 506, + 396 + ], + "lines": [], + "index": 23.5, + "bbox_fs": [ + 86, + 347, + 506, + 397 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 196, + 401, + 415, + 430 + ], + "lines": [ + { + "bbox": [ + 196, + 401, + 415, + 430 + ], + "spans": [ + { + "bbox": [ + 196, + 401, + 415, + 430 + ], + "score": 0.91, + "content": "2 ^ { b } = 2 ^ { \\sum _ { i \\geq 0 } b _ { i } 2 ^ { i } } = \\prod _ { i \\geq 0 } 2 ^ { b _ { i } 2 ^ { i } } = \\prod _ { i \\geq 0 } ( 1 + b _ { i } \\cdot ( 2 ^ { 2 ^ { i } } - 1 ) ) .", + "type": "interline_equation", + "image_path": "8c23276368b1b8c7d81c896fefea584c2c7d3d49e6ccd58490eca1b2a9f47135.jpg" + } + ] + } + ], + "index": 26.5, + "virtual_lines": [ + { + "bbox": [ + 196, + 401, + 415, + 415.5 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 196, + 415.5, + 415, + 430.0 + ], + "spans": [], + "index": 27 + } + ] + }, + { + "type": "text", + "bbox": [ + 92, + 434, + 465, + 447 + ], + "lines": [ + { + "bbox": [ + 88, + 434, + 467, + 448 + ], + "spans": [ + { + "bbox": [ + 88, + 434, + 467, + 448 + ], + "score": 1.0, + "content": "191 As with division the numerical stability depends on the truncation used for multiplication.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28, + "bbox_fs": [ + 88, + 434, + 467, + 448 + ] + }, + { + "type": "text", + "bbox": [ + 100, + 457, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 507, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 507, + 471 + ], + "score": 1.0, + "content": "Inverse square root Aly and Smart [2019] have proposed to compute square root using Gold-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "score": 1.0, + "content": "schmidt and Raphson-Newton iterations. We could combine this with the division above. However, Lu", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 480, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 492 + ], + "score": 1.0, + "content": "et al. [2020] have proposed a more direct computation that avoids running two successive iterations.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 457, + 507, + 492 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 502, + 505, + 570 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 446, + 515 + ], + "score": 1.0, + "content": "Uniformly random fractional number Limiting ourselves to intervals of the form", + "type": "text" + }, + { + "bbox": [ + 446, + 503, + 490, + 515 + ], + "score": 0.92, + "content": "[ x , x + 2 ^ { e } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 490, + 502, + 506, + 515 + ], + "score": 1.0, + "content": "for", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 514, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 222, + 526 + ], + "score": 1.0, + "content": "a potentially negative integer", + "type": "text" + }, + { + "bbox": [ + 223, + 516, + 228, + 524 + ], + "score": 0.53, + "content": "e", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 514, + 426, + 526 + ], + "score": 1.0, + "content": ", we can reduce the problem to generate a random", + "type": "text" + }, + { + "bbox": [ + 427, + 514, + 457, + 525 + ], + "score": 0.92, + "content": "( f + { \\dot { e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 514, + 506, + 526 + ], + "score": 1.0, + "content": "-bit number", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 524, + 502, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 133, + 538 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 526, + 141, + 537 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 524, + 443, + 538 + ], + "score": 1.0, + "content": "is the fixed-point precision. Recall that we represent a fractional number", + "type": "text" + }, + { + "bbox": [ + 443, + 528, + 451, + 536 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 524, + 464, + 538 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 464, + 525, + 502, + 538 + ], + "score": 0.93, + "content": "\\lfloor x \\cdot 2 ^ { - f } \\rceil", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 537, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 193, + 549 + ], + "score": 1.0, + "content": "Generating a random", + "type": "text" + }, + { + "bbox": [ + 193, + 539, + 200, + 547 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 537, + 505, + 549 + ], + "score": 1.0, + "content": "-bit number is straight-forward using random bits, which in our protocol can", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "score": 1.0, + "content": "be generated as presented by Damgård et al. [2019]. In the context of our protocol however, Dalskov", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 559, + 493, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 559, + 493, + 570 + ], + "score": 1.0, + "content": "et al. [2021] have a presented a more efficient approach that involves mixed-circuit computation.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 502, + 506, + 570 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 581, + 505, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "Communication cost Table 1 show the total communication cost of some of the building blocks", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 590, + 507, + 606 + ], + "spans": [ + { + "bbox": [ + 104, + 590, + 184, + 606 + ], + "score": 1.0, + "content": "in our protocol for", + "type": "text" + }, + { + "bbox": [ + 184, + 593, + 215, + 604 + ], + "score": 0.9, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 590, + 363, + 606 + ], + "score": 1.0, + "content": ". This setting mandates the modulus", + "type": "text" + }, + { + "bbox": [ + 364, + 592, + 382, + 603 + ], + "score": 0.86, + "content": "2 ^ { 1 2 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 590, + 507, + 606 + ], + "score": 1.0, + "content": "because the division protocol", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 603, + 198, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 181, + 616 + ], + "score": 1.0, + "content": "requires bit length", + "type": "text" + }, + { + "bbox": [ + 182, + 604, + 194, + 615 + ], + "score": 0.86, + "content": "4 f", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 603, + 198, + 616 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 104, + 581, + 507, + 616 + ] + }, + { + "type": "title", + "bbox": [ + 101, + 630, + 304, + 644 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 306, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 306, + 647 + ], + "score": 1.0, + "content": "4 Machine Learning Building Blocks", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 504, + 677 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "In this section, we will use the building blocks in Section 3 to construct high-level computational", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 664, + 216, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 216, + 679 + ], + "score": 1.0, + "content": "modules for deep learning.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 654, + 505, + 679 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 689, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Fully connected layers Both forward and back-propagation of fully connected layers can be seen", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "as matrix multiplications and thus can be implemented using dot products. A particular challenge in", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "secure computation is to compute a number of outputs in parallel in order to save communication", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 688, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 201, + 88, + 411, + 222 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 125, + 70, + 484, + 83 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 123, + 67, + 482, + 85 + ], + "spans": [ + { + "bbox": [ + 123, + 67, + 348, + 85 + ], + "score": 1.0, + "content": "Table 1: Communication cost of select computation for", + "type": "text" + }, + { + "bbox": [ + 348, + 71, + 379, + 83 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 67, + 464, + 85 + ], + "score": 1.0, + "content": "and integer modulus", + "type": "text" + }, + { + "bbox": [ + 464, + 70, + 482, + 81 + ], + "score": 0.84, + "content": "2 ^ { 1 2 8 }", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 201, + 88, + 411, + 222 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 201, + 88, + 411, + 222 + ], + "spans": [ + { + "bbox": [ + 201, + 88, + 411, + 222 + ], + "score": 0.981, + "html": "
Bits
Integer multiplication384
Probabilistic truncation Nearest truncation1,536 4,462
Comparison1,369
Division (prob. truncation)29,866
Division (nearest truncation)57,798
Exponentiation (prob. truncation)77,684
Exponentiation (nearest truncation)
171,638
Invert square root (prob. truncation) Invert square root (nearest truncation)20,073 27,699
", + "type": "table", + "image_path": "9fd53d77e94058a5729b0569126beb6fc6cee5af420d0afe5b03e2771b4647cb.jpg" + } + ] + } + ], + "index": 5.5, + "virtual_lines": [ + { + "bbox": [ + 201, + 88, + 411, + 101.4 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 201, + 101.4, + 411, + 114.80000000000001 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 201, + 114.80000000000001, + 411, + 128.20000000000002 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 201, + 128.20000000000002, + 411, + 141.60000000000002 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 201, + 141.60000000000002, + 411, + 155.00000000000003 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 201, + 155.00000000000003, + 411, + 168.40000000000003 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 201, + 168.40000000000003, + 411, + 181.80000000000004 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 201, + 181.80000000000004, + 411, + 195.20000000000005 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 201, + 195.20000000000005, + 411, + 208.60000000000005 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 201, + 208.60000000000005, + 411, + 222.00000000000006 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 91, + 241, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 90, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 90, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "10 rounds. We solve this by having a dedicated infrastructure in our implementation that computes all dot", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 90, + 252, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 90, + 252, + 506, + 265 + ], + "score": 1.0, + "content": "11 products for a matrix multiplication in a single batch, thus combining all necessary communication.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 104, + 275, + 506, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "score": 1.0, + "content": "2D convolution layers Similar to fully connected layers, 2D convolution and its corresponding", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "gradient can be implemented using only dot products, and we again compute several output values in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 297, + 142, + 309 + ], + "spans": [ + { + "bbox": [ + 104, + 297, + 142, + 309 + ], + "score": 1.0, + "content": "parallel.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 86, + 319, + 451, + 333 + ], + "lines": [ + { + "bbox": [ + 84, + 319, + 452, + 334 + ], + "spans": [ + { + "bbox": [ + 84, + 319, + 452, + 334 + ], + "score": 1.0, + "content": "215 Rectified Linear Unit (ReLU) ReLU Nair and Hinton [2010] is defined as follows:", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 336, + 364, + 365 + ], + "lines": [ + { + "bbox": [ + 244, + 336, + 364, + 365 + ], + "spans": [ + { + "bbox": [ + 244, + 336, + 364, + 365 + ], + "score": 0.94, + "content": "{ \\mathsf { R e L U } } ( x ) : = { \\left\\{ \\begin{array} { l l } { x , } & { { \\mathrm { i f ~ } } x > 0 } \\\\ { 0 . } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "6552a81b7732498e72666ed8446d188466cdfbd1913c006a8ad902a1062afcf8.jpg" + } + ] + } + ], + "index": 17.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 336, + 364, + 350.5 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 244, + 350.5, + 364, + 365.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 86, + 369, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 85, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 85, + 371, + 100, + 381 + ], + "score": 1.0, + "content": "216", + "type": "text" + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "It can thus be implemented as a comparison followed by an oblivious selection. For back-propagation,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 85, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 85, + 382, + 100, + 392 + ], + "score": 1.0, + "content": "217", + "type": "text" + }, + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "it is advantageous to reuse the comparison results from forward propagation due to the relatively high", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 85, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 85, + 392, + 100, + 403 + ], + "score": 1.0, + "content": "218", + "type": "text" + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "cost in secure computation. Note that the comparison results are stored in secret-shared form and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 85, + 401, + 255, + 415 + ], + "spans": [ + { + "bbox": [ + 85, + 403, + 100, + 414 + ], + "score": 1.0, + "content": "219", + "type": "text" + }, + { + "bbox": [ + 105, + 401, + 255, + 415 + ], + "score": 1.0, + "content": "thus there is no reduction in security.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 86, + 424, + 506, + 470 + ], + "lines": [ + { + "bbox": [ + 86, + 424, + 507, + 439 + ], + "spans": [ + { + "bbox": [ + 86, + 427, + 100, + 437 + ], + "score": 1.0, + "content": "220", + "type": "text" + }, + { + "bbox": [ + 105, + 424, + 507, + 439 + ], + "score": 1.0, + "content": "Max pooling Similar to ReLU, max pooling can be reduced to comparison and oblivious selection.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 85, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 85, + 437, + 100, + 448 + ], + "score": 1.0, + "content": "221", + "type": "text" + }, + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "In secure computation, it saves communication rounds if the process uses a balanced tree rather than", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 85, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 85, + 448, + 100, + 459 + ], + "score": 1.0, + "content": "222", + "type": "text" + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "iterating over all input values of one maximum computation. For back-propagation it again pays off", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 86, + 457, + 456, + 470 + ], + "spans": [ + { + "bbox": [ + 86, + 460, + 100, + 469 + ], + "score": 1.0, + "content": "223", + "type": "text" + }, + { + "bbox": [ + 105, + 457, + 456, + 470 + ], + "score": 1.0, + "content": "to the store intermediate results from forward propagation, again in secret-shared form.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 91, + 480, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 88, + 479, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 88, + 479, + 506, + 494 + ], + "score": 1.0, + "content": "224 Softmax and cross entropy loss This combination requires computing the following gradient for", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 87, + 492, + 182, + 504 + ], + "spans": [ + { + "bbox": [ + 87, + 492, + 182, + 504 + ], + "score": 1.0, + "content": "225 back-propagation:", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "interline_equation", + "bbox": [ + 166, + 506, + 444, + 538 + ], + "lines": [ + { + "bbox": [ + 166, + 506, + 444, + 538 + ], + "spans": [ + { + "bbox": [ + 166, + 506, + 444, + 538 + ], + "score": 0.93, + "content": "\\nabla i : = \\frac { \\partial \\ell } { \\partial x _ { i } } = \\frac { \\partial } { \\partial x _ { i } } \\Big ( - \\sum _ { k } y _ { k } \\cdot x _ { k } + \\log \\sum _ { j } e ^ { x _ { j } } \\Big ) = - y _ { i } + \\frac { e ^ { x _ { i } } } { \\sum _ { j } e ^ { x _ { j } } } ,", + "type": "interline_equation", + "image_path": "eae777e4bc355b0a5c52d65a7001eadc3f0665c189d84dfb531be701ff493e40.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 166, + 506, + 444, + 516.6666666666666 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 166, + 516.6666666666666, + 444, + 527.3333333333333 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 166, + 527.3333333333333, + 444, + 537.9999999999999 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "text", + "bbox": [ + 88, + 542, + 507, + 565 + ], + "lines": [ + { + "bbox": [ + 84, + 541, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 84, + 541, + 132, + 555 + ], + "score": 1.0, + "content": "226 where", + "type": "text" + }, + { + "bbox": [ + 132, + 544, + 142, + 554 + ], + "score": 0.85, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 541, + 393, + 555 + ], + "score": 1.0, + "content": "denotes an element of the ground truth as a one-hot vector, and", + "type": "text" + }, + { + "bbox": [ + 393, + 544, + 404, + 554 + ], + "score": 0.86, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 541, + 506, + 555 + ], + "score": 1.0, + "content": "denotes the output of the", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 84, + 551, + 149, + 567 + ], + "spans": [ + { + "bbox": [ + 84, + 551, + 149, + 567 + ], + "score": 1.0, + "content": "227 last layer.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 86, + 569, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 86, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 86, + 572, + 99, + 582 + ], + "score": 1.0, + "content": "228", + "type": "text" + }, + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "On the right hand side of eq. (1), the values in the denominator are potentially large due to the use", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 86, + 582, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 86, + 582, + 99, + 592 + ], + "score": 1.0, + "content": "229", + "type": "text" + }, + { + "bbox": [ + 106, + 582, + 505, + 592 + ], + "score": 1.0, + "content": "of the exponential. This is prone to numerical overflow in our quantized representation because the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 86, + 590, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 86, + 594, + 99, + 603 + ], + "score": 1.0, + "content": "230", + "type": "text" + }, + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "score": 1.0, + "content": "latter puts relatively strict limits on the values. We therefore optimize the computation by computing", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 86, + 602, + 244, + 615 + ], + "spans": [ + { + "bbox": [ + 86, + 605, + 99, + 614 + ], + "score": 1.0, + "content": "231", + "type": "text" + }, + { + "bbox": [ + 105, + 602, + 244, + 615 + ], + "score": 1.0, + "content": "the maximum of the input values:", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 612, + 342, + 631 + ], + "lines": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "spans": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "score": 0.92, + "content": "m = \\operatorname* { m a x } _ { j } ( \\{ x _ { j } \\} ) .", + "type": "interline_equation", + "image_path": "6c2446d51ceae645baff7cf2c22ccb1d25b3d2e64c166c57a212c0dae2a3f332.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "spans": [], + "index": 38 + } + ] + }, + { + "type": "text", + "bbox": [ + 87, + 633, + 180, + 645 + ], + "lines": [ + { + "bbox": [ + 84, + 632, + 181, + 646 + ], + "spans": [ + { + "bbox": [ + 84, + 632, + 181, + 646 + ], + "score": 1.0, + "content": "232 Then we compute", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "interline_equation", + "bbox": [ + 222, + 643, + 389, + 673 + ], + "lines": [ + { + "bbox": [ + 222, + 643, + 389, + 673 + ], + "spans": [ + { + "bbox": [ + 222, + 643, + 389, + 673 + ], + "score": 0.94, + "content": "{ \\frac { e ^ { x _ { i } - m } } { \\sum _ { j } e ^ { x _ { j } - m } } } = { \\frac { e ^ { x _ { i } } e ^ { - m } } { ( \\sum _ { j } e ^ { x _ { j } } ) e ^ { - m } } } = { \\frac { e ^ { x _ { i } } } { \\sum _ { j } e ^ { x _ { j } } } } .", + "type": "interline_equation", + "image_path": "e97d4b3c6d76abf1abd9d00e5c9538cb1f5ba3ae1df09857309d21f1c004e343.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 222, + 643, + 389, + 658.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 222, + 658.0, + 389, + 673.0 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 86, + 674, + 506, + 723 + ], + "lines": [ + { + "bbox": [ + 86, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 86, + 675, + 100, + 685 + ], + "score": 1.0, + "content": "233", + "type": "text" + }, + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "All the exponents on the left-most term are at most zero, and thus the dividend is at most one and the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 86, + 685, + 505, + 696 + ], + "spans": [ + { + "bbox": [ + 86, + 686, + 100, + 696 + ], + "score": 1.0, + "content": "234", + "type": "text" + }, + { + "bbox": [ + 106, + 685, + 505, + 696 + ], + "score": 1.0, + "content": "divisor is at most the number of labels (which is 10 in MNIST). The same technique can be used to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 86, + 694, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 86, + 700, + 100, + 710 + ], + "score": 1.0, + "content": "235", + "type": "text" + }, + { + "bbox": [ + 103, + 694, + 393, + 714 + ], + "score": 1.0, + "content": "compute the sigmoid activation function, as sigmoid(x) = 11+exp(−x)", + "type": "text" + }, + { + "bbox": [ + 311, + 695, + 456, + 713 + ], + "score": 0.56, + "content": "\\begin{array} { r } { \\mathrm { \\begin{array} { r } { \\mathrm { i d } ( x ) = \\frac { 1 } { 1 + \\exp ( - x ) } = \\frac { \\exp ( 0 ) } { \\exp ( 0 ) + \\exp ( x ) } } } \\end{array} } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 694, + 506, + 714 + ], + "score": 1.0, + "content": "is a special", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 86, + 711, + 173, + 722 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 100, + 721 + ], + "score": 1.0, + "content": "236", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 173, + 722 + ], + "score": 1.0, + "content": "case of softmax.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 201, + 88, + 411, + 222 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 125, + 70, + 484, + 83 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 123, + 67, + 482, + 85 + ], + "spans": [ + { + "bbox": [ + 123, + 67, + 348, + 85 + ], + "score": 1.0, + "content": "Table 1: Communication cost of select computation for", + "type": "text" + }, + { + "bbox": [ + 348, + 71, + 379, + 83 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 67, + 464, + 85 + ], + "score": 1.0, + "content": "and integer modulus", + "type": "text" + }, + { + "bbox": [ + 464, + 70, + 482, + 81 + ], + "score": 0.84, + "content": "2 ^ { 1 2 8 }", + "type": "inline_equation" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 201, + 88, + 411, + 222 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 201, + 88, + 411, + 222 + ], + "spans": [ + { + "bbox": [ + 201, + 88, + 411, + 222 + ], + "score": 0.981, + "html": "
Bits
Integer multiplication384
Probabilistic truncation Nearest truncation1,536 4,462
Comparison1,369
Division (prob. truncation)29,866
Division (nearest truncation)57,798
Exponentiation (prob. truncation)77,684
Exponentiation (nearest truncation)
171,638
Invert square root (prob. truncation) Invert square root (nearest truncation)20,073 27,699
", + "type": "table", + "image_path": "9fd53d77e94058a5729b0569126beb6fc6cee5af420d0afe5b03e2771b4647cb.jpg" + } + ] + } + ], + "index": 5.5, + "virtual_lines": [ + { + "bbox": [ + 201, + 88, + 411, + 101.4 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 201, + 101.4, + 411, + 114.80000000000001 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 201, + 114.80000000000001, + 411, + 128.20000000000002 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 201, + 128.20000000000002, + 411, + 141.60000000000002 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 201, + 141.60000000000002, + 411, + 155.00000000000003 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 201, + 155.00000000000003, + 411, + 168.40000000000003 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 201, + 168.40000000000003, + 411, + 181.80000000000004 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 201, + 181.80000000000004, + 411, + 195.20000000000005 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 201, + 195.20000000000005, + 411, + 208.60000000000005 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 201, + 208.60000000000005, + 411, + 222.00000000000006 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 2.75 + }, + { + "type": "index", + "bbox": [ + 91, + 241, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 90, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 90, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "10 rounds. We solve this by having a dedicated infrastructure in our implementation that computes all dot", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 252, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 90, + 252, + 506, + 265 + ], + "score": 1.0, + "content": "11 products for a matrix multiplication in a single batch, thus combining all necessary communication.", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + } + ], + "index": 11.5, + "bbox_fs": [ + 90, + 241, + 506, + 265 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 275, + 506, + 309 + ], + "lines": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 274, + 505, + 289 + ], + "score": 1.0, + "content": "2D convolution layers Similar to fully connected layers, 2D convolution and its corresponding", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "gradient can be implemented using only dot products, and we again compute several output values in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 297, + 142, + 309 + ], + "spans": [ + { + "bbox": [ + 104, + 297, + 142, + 309 + ], + "score": 1.0, + "content": "parallel.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14, + "bbox_fs": [ + 104, + 274, + 505, + 309 + ] + }, + { + "type": "text", + "bbox": [ + 86, + 319, + 451, + 333 + ], + "lines": [ + { + "bbox": [ + 84, + 319, + 452, + 334 + ], + "spans": [ + { + "bbox": [ + 84, + 319, + 452, + 334 + ], + "score": 1.0, + "content": "215 Rectified Linear Unit (ReLU) ReLU Nair and Hinton [2010] is defined as follows:", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16, + "bbox_fs": [ + 84, + 319, + 452, + 334 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 244, + 336, + 364, + 365 + ], + "lines": [ + { + "bbox": [ + 244, + 336, + 364, + 365 + ], + "spans": [ + { + "bbox": [ + 244, + 336, + 364, + 365 + ], + "score": 0.94, + "content": "{ \\mathsf { R e L U } } ( x ) : = { \\left\\{ \\begin{array} { l l } { x , } & { { \\mathrm { i f ~ } } x > 0 } \\\\ { 0 . } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }", + "type": "interline_equation", + "image_path": "6552a81b7732498e72666ed8446d188466cdfbd1913c006a8ad902a1062afcf8.jpg" + } + ] + } + ], + "index": 17.5, + "virtual_lines": [ + { + "bbox": [ + 244, + 336, + 364, + 350.5 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 244, + 350.5, + 364, + 365.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "index", + "bbox": [ + 86, + 369, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 85, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 85, + 371, + 100, + 381 + ], + "score": 1.0, + "content": "216", + "type": "text" + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "It can thus be implemented as a comparison followed by an oblivious selection. For back-propagation,", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 380, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 85, + 382, + 100, + 392 + ], + "score": 1.0, + "content": "217", + "type": "text" + }, + { + "bbox": [ + 105, + 380, + 505, + 393 + ], + "score": 1.0, + "content": "it is advantageous to reuse the comparison results from forward propagation due to the relatively high", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 391, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 85, + 392, + 100, + 403 + ], + "score": 1.0, + "content": "218", + "type": "text" + }, + { + "bbox": [ + 105, + 391, + 505, + 403 + ], + "score": 1.0, + "content": "cost in secure computation. Note that the comparison results are stored in secret-shared form and", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 401, + 255, + 415 + ], + "spans": [ + { + "bbox": [ + 85, + 403, + 100, + 414 + ], + "score": 1.0, + "content": "219", + "type": "text" + }, + { + "bbox": [ + 105, + 401, + 255, + 415 + ], + "score": 1.0, + "content": "thus there is no reduction in security.", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 424, + 507, + 439 + ], + "spans": [ + { + "bbox": [ + 86, + 427, + 100, + 437 + ], + "score": 1.0, + "content": "220", + "type": "text" + }, + { + "bbox": [ + 105, + 424, + 507, + 439 + ], + "score": 1.0, + "content": "Max pooling Similar to ReLU, max pooling can be reduced to comparison and oblivious selection.", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 85, + 437, + 100, + 448 + ], + "score": 1.0, + "content": "221", + "type": "text" + }, + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "In secure computation, it saves communication rounds if the process uses a balanced tree rather than", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 85, + 448, + 100, + 459 + ], + "score": 1.0, + "content": "222", + "type": "text" + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "iterating over all input values of one maximum computation. For back-propagation it again pays off", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 457, + 456, + 470 + ], + "spans": [ + { + "bbox": [ + 86, + 460, + 100, + 469 + ], + "score": 1.0, + "content": "223", + "type": "text" + }, + { + "bbox": [ + 105, + 457, + 456, + 470 + ], + "score": 1.0, + "content": "to the store intermediate results from forward propagation, again in secret-shared form.", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 479, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 88, + 479, + 506, + 494 + ], + "score": 1.0, + "content": "224 Softmax and cross entropy loss This combination requires computing the following gradient for", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 87, + 492, + 182, + 504 + ], + "spans": [ + { + "bbox": [ + 87, + 492, + 182, + 504 + ], + "score": 1.0, + "content": "225 back-propagation:", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + } + ], + "index": 20.5, + "bbox_fs": [ + 85, + 369, + 506, + 415 + ] + }, + { + "type": "index", + "bbox": [ + 86, + 424, + 506, + 470 + ], + "lines": [], + "index": 24.5, + "bbox_fs": [ + 85, + 424, + 507, + 470 + ], + "lines_deleted": true + }, + { + "type": "index", + "bbox": [ + 91, + 480, + 505, + 503 + ], + "lines": [], + "index": 27.5, + "bbox_fs": [ + 87, + 479, + 506, + 504 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 166, + 506, + 444, + 538 + ], + "lines": [ + { + "bbox": [ + 166, + 506, + 444, + 538 + ], + "spans": [ + { + "bbox": [ + 166, + 506, + 444, + 538 + ], + "score": 0.93, + "content": "\\nabla i : = \\frac { \\partial \\ell } { \\partial x _ { i } } = \\frac { \\partial } { \\partial x _ { i } } \\Big ( - \\sum _ { k } y _ { k } \\cdot x _ { k } + \\log \\sum _ { j } e ^ { x _ { j } } \\Big ) = - y _ { i } + \\frac { e ^ { x _ { i } } } { \\sum _ { j } e ^ { x _ { j } } } ,", + "type": "interline_equation", + "image_path": "eae777e4bc355b0a5c52d65a7001eadc3f0665c189d84dfb531be701ff493e40.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 166, + 506, + 444, + 516.6666666666666 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 166, + 516.6666666666666, + 444, + 527.3333333333333 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 166, + 527.3333333333333, + 444, + 537.9999999999999 + ], + "spans": [], + "index": 31 + } + ] + }, + { + "type": "index", + "bbox": [ + 88, + 542, + 507, + 565 + ], + "lines": [ + { + "bbox": [ + 84, + 541, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 84, + 541, + 132, + 555 + ], + "score": 1.0, + "content": "226 where", + "type": "text" + }, + { + "bbox": [ + 132, + 544, + 142, + 554 + ], + "score": 0.85, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 541, + 393, + 555 + ], + "score": 1.0, + "content": "denotes an element of the ground truth as a one-hot vector, and", + "type": "text" + }, + { + "bbox": [ + 393, + 544, + 404, + 554 + ], + "score": 0.86, + "content": "x _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 541, + 506, + 555 + ], + "score": 1.0, + "content": "denotes the output of the", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 551, + 149, + 567 + ], + "spans": [ + { + "bbox": [ + 84, + 551, + 149, + 567 + ], + "score": 1.0, + "content": "227 last layer.", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 86, + 572, + 99, + 582 + ], + "score": 1.0, + "content": "228", + "type": "text" + }, + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "On the right hand side of eq. (1), the values in the denominator are potentially large due to the use", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 582, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 86, + 582, + 99, + 592 + ], + "score": 1.0, + "content": "229", + "type": "text" + }, + { + "bbox": [ + 106, + 582, + 505, + 592 + ], + "score": 1.0, + "content": "of the exponential. This is prone to numerical overflow in our quantized representation because the", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 590, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 86, + 594, + 99, + 603 + ], + "score": 1.0, + "content": "230", + "type": "text" + }, + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "score": 1.0, + "content": "latter puts relatively strict limits on the values. We therefore optimize the computation by computing", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 602, + 244, + 615 + ], + "spans": [ + { + "bbox": [ + 86, + 605, + 99, + 614 + ], + "score": 1.0, + "content": "231", + "type": "text" + }, + { + "bbox": [ + 105, + 602, + 244, + 615 + ], + "score": 1.0, + "content": "the maximum of the input values:", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + } + ], + "index": 32.5, + "bbox_fs": [ + 84, + 541, + 506, + 567 + ] + }, + { + "type": "index", + "bbox": [ + 86, + 569, + 505, + 614 + ], + "lines": [], + "index": 35.5, + "bbox_fs": [ + 86, + 569, + 505, + 615 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 268, + 612, + 342, + 631 + ], + "lines": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "spans": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "score": 0.92, + "content": "m = \\operatorname* { m a x } _ { j } ( \\{ x _ { j } \\} ) .", + "type": "interline_equation", + "image_path": "6c2446d51ceae645baff7cf2c22ccb1d25b3d2e64c166c57a212c0dae2a3f332.jpg" + } + ] + } + ], + "index": 38, + "virtual_lines": [ + { + "bbox": [ + 268, + 612, + 342, + 631 + ], + "spans": [], + "index": 38 + } + ] + }, + { + "type": "text", + "bbox": [ + 87, + 633, + 180, + 645 + ], + "lines": [ + { + "bbox": [ + 84, + 632, + 181, + 646 + ], + "spans": [ + { + "bbox": [ + 84, + 632, + 181, + 646 + ], + "score": 1.0, + "content": "232 Then we compute", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39, + "bbox_fs": [ + 84, + 632, + 181, + 646 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 222, + 643, + 389, + 673 + ], + "lines": [ + { + "bbox": [ + 222, + 643, + 389, + 673 + ], + "spans": [ + { + "bbox": [ + 222, + 643, + 389, + 673 + ], + "score": 0.94, + "content": "{ \\frac { e ^ { x _ { i } - m } } { \\sum _ { j } e ^ { x _ { j } - m } } } = { \\frac { e ^ { x _ { i } } e ^ { - m } } { ( \\sum _ { j } e ^ { x _ { j } } ) e ^ { - m } } } = { \\frac { e ^ { x _ { i } } } { \\sum _ { j } e ^ { x _ { j } } } } .", + "type": "interline_equation", + "image_path": "e97d4b3c6d76abf1abd9d00e5c9538cb1f5ba3ae1df09857309d21f1c004e343.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 222, + 643, + 389, + 658.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 222, + 658.0, + 389, + 673.0 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "index", + "bbox": [ + 86, + 674, + 506, + 723 + ], + "lines": [ + { + "bbox": [ + 86, + 674, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 86, + 675, + 100, + 685 + ], + "score": 1.0, + "content": "233", + "type": "text" + }, + { + "bbox": [ + 105, + 674, + 505, + 685 + ], + "score": 1.0, + "content": "All the exponents on the left-most term are at most zero, and thus the dividend is at most one and the", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 685, + 505, + 696 + ], + "spans": [ + { + "bbox": [ + 86, + 686, + 100, + 696 + ], + "score": 1.0, + "content": "234", + "type": "text" + }, + { + "bbox": [ + 106, + 685, + 505, + 696 + ], + "score": 1.0, + "content": "divisor is at most the number of labels (which is 10 in MNIST). The same technique can be used to", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 694, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 86, + 700, + 100, + 710 + ], + "score": 1.0, + "content": "235", + "type": "text" + }, + { + "bbox": [ + 103, + 694, + 393, + 714 + ], + "score": 1.0, + "content": "compute the sigmoid activation function, as sigmoid(x) = 11+exp(−x)", + "type": "text" + }, + { + "bbox": [ + 311, + 695, + 456, + 713 + ], + "score": 0.56, + "content": "\\begin{array} { r } { \\mathrm { \\begin{array} { r } { \\mathrm { i d } ( x ) = \\frac { 1 } { 1 + \\exp ( - x ) } = \\frac { \\exp ( 0 ) } { \\exp ( 0 ) + \\exp ( x ) } } } \\end{array} } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 694, + 506, + 714 + ], + "score": 1.0, + "content": "is a special", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 711, + 173, + 722 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 100, + 721 + ], + "score": 1.0, + "content": "236", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 173, + 722 + ], + "score": 1.0, + "content": "case of softmax.", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 72, + 507, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 75, + 99, + 84 + ], + "score": 1.0, + "content": "237", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 72, + 507, + 86 + ], + "score": 1.0, + "content": "Stochastic gradient descent The model parameter update in SGD only involves basic arithmetic:", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 79, + 509, + 104 + ], + "spans": [ + { + "bbox": [ + 86, + 88, + 99, + 97 + ], + "score": 1.0, + "content": "238", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 84, + 205, + 99 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\theta _ { j } \\theta _ { j } - \\frac { \\gamma } { B } \\sum _ { i = 1 } ^ { B } \\bigtriangledown _ { i j } } \\end{array}", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 205, + 79, + 233, + 104 + ], + "score": 1.0, + "content": "where", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 233, + 86, + 243, + 98 + ], + "score": 0.87, + "content": "\\theta _ { j }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 244, + 79, + 357, + 104 + ], + "score": 1.0, + "content": "is the parameter indexed by", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 358, + 86, + 378, + 97 + ], + "score": 0.3, + "content": "j , B", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 378, + 79, + 469, + 104 + ], + "score": 1.0, + "content": "is the mini-batch size,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 469, + 86, + 495, + 97 + ], + "score": 0.91, + "content": "\\gamma > 0", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 495, + 79, + 509, + 104 + ], + "score": 1.0, + "content": "is", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 96, + 505, + 110 + ], + "spans": [ + { + "bbox": [ + 85, + 98, + 100, + 109 + ], + "score": 1.0, + "content": "239", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 96, + 192, + 110 + ], + "score": 1.0, + "content": "the learning rate, and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 193, + 99, + 209, + 109 + ], + "score": 0.89, + "content": "\\nabla i j", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 210, + 96, + 387, + 110 + ], + "score": 1.0, + "content": "is the gradient of the loss with respect to the", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 394, + 96, + 505, + 110 + ], + "score": 1.0, + "content": "’th sample in the mini-batch", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 106, + 505, + 121 + ], + "spans": [ + { + "bbox": [ + 85, + 109, + 100, + 119 + ], + "score": 1.0, + "content": "240", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 106, + 179, + 121 + ], + "score": 1.0, + "content": "and the parameter", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 180, + 108, + 189, + 119 + ], + "score": 0.87, + "content": "\\theta _ { j }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 190, + 106, + 505, + 121 + ], + "score": 1.0, + "content": ". In order to tackle the limited precision with quantization, we defer dividing by", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 86, + 120, + 99, + 129 + ], + "score": 1.0, + "content": "241", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "the batch size to the model update. This means that we do not divide the gradient value by the batch", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 129, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 85, + 131, + 100, + 141 + ], + "score": 1.0, + "content": "242", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 129, + 505, + 142 + ], + "score": 1.0, + "content": "size when computing them as described in the previous paragraph. Instead, we divide the model", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 140, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 85, + 142, + 100, + 153 + ], + "score": 1.0, + "content": "243", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 140, + 506, + 153 + ], + "score": 1.0, + "content": "update by the batch size. Since we use a batch size that is a power of two (128), it is sufficient to use", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 85, + 153, + 100, + 163 + ], + "score": 1.0, + "content": "244", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "probabilistic truncation instead of full-blown division. This saves both time and decreases the error.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + } + ], + "index": 43.5, + "bbox_fs": [ + 86, + 674, + 506, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 86, + 72, + 505, + 163 + ], + "lines": [ + { + "bbox": [ + 86, + 72, + 507, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 75, + 99, + 84 + ], + "score": 1.0, + "content": "237", + "type": "text" + }, + { + "bbox": [ + 105, + 72, + 507, + 86 + ], + "score": 1.0, + "content": "Stochastic gradient descent The model parameter update in SGD only involves basic arithmetic:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 86, + 79, + 509, + 104 + ], + "spans": [ + { + "bbox": [ + 86, + 88, + 99, + 97 + ], + "score": 1.0, + "content": "238", + "type": "text" + }, + { + "bbox": [ + 106, + 84, + 205, + 99 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\theta _ { j } \\theta _ { j } - \\frac { \\gamma } { B } \\sum _ { i = 1 } ^ { B } \\bigtriangledown _ { i j } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 79, + 233, + 104 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 233, + 86, + 243, + 98 + ], + "score": 0.87, + "content": "\\theta _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 79, + 357, + 104 + ], + "score": 1.0, + "content": "is the parameter indexed by", + "type": "text" + }, + { + "bbox": [ + 358, + 86, + 378, + 97 + ], + "score": 0.3, + "content": "j , B", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 79, + 469, + 104 + ], + "score": 1.0, + "content": "is the mini-batch size,", + "type": "text" + }, + { + "bbox": [ + 469, + 86, + 495, + 97 + ], + "score": 0.91, + "content": "\\gamma > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 79, + 509, + 104 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 85, + 96, + 505, + 110 + ], + "spans": [ + { + "bbox": [ + 85, + 98, + 100, + 109 + ], + "score": 1.0, + "content": "239", + "type": "text" + }, + { + "bbox": [ + 105, + 96, + 192, + 110 + ], + "score": 1.0, + "content": "the learning rate, and", + "type": "text" + }, + { + "bbox": [ + 193, + 99, + 209, + 109 + ], + "score": 0.89, + "content": "\\nabla i j", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 96, + 387, + 110 + ], + "score": 1.0, + "content": "is the gradient of the loss with respect to the", + "type": "text" + }, + { + "bbox": [ + 394, + 96, + 505, + 110 + ], + "score": 1.0, + "content": "’th sample in the mini-batch", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 85, + 106, + 505, + 121 + ], + "spans": [ + { + "bbox": [ + 85, + 109, + 100, + 119 + ], + "score": 1.0, + "content": "240", + "type": "text" + }, + { + "bbox": [ + 104, + 106, + 179, + 121 + ], + "score": 1.0, + "content": "and the parameter", + "type": "text" + }, + { + "bbox": [ + 180, + 108, + 189, + 119 + ], + "score": 0.87, + "content": "\\theta _ { j }", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 106, + 505, + 121 + ], + "score": 1.0, + "content": ". In order to tackle the limited precision with quantization, we defer dividing by", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 86, + 118, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 86, + 120, + 99, + 129 + ], + "score": 1.0, + "content": "241", + "type": "text" + }, + { + "bbox": [ + 106, + 118, + 505, + 130 + ], + "score": 1.0, + "content": "the batch size to the model update. This means that we do not divide the gradient value by the batch", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 85, + 129, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 85, + 131, + 100, + 141 + ], + "score": 1.0, + "content": "242", + "type": "text" + }, + { + "bbox": [ + 106, + 129, + 505, + 142 + ], + "score": 1.0, + "content": "size when computing them as described in the previous paragraph. Instead, we divide the model", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 85, + 140, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 85, + 142, + 100, + 153 + ], + "score": 1.0, + "content": "243", + "type": "text" + }, + { + "bbox": [ + 105, + 140, + 506, + 153 + ], + "score": 1.0, + "content": "update by the batch size. Since we use a batch size that is a power of two (128), it is sufficient to use", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 85, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 85, + 153, + 100, + 163 + ], + "score": 1.0, + "content": "244", + "type": "text" + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "probabilistic truncation instead of full-blown division. This saves both time and decreases the error.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 99, + 179, + 505, + 213 + ], + "lines": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "Adam The main difference to SGD in terms of basic computational operations is the additional", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "use of an inverse square root. We again defer the division by the batch size to just before the model", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 200, + 140, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 140, + 215 + ], + "score": 1.0, + "content": "update.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 99, + 230, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "score": 1.0, + "content": "Parameter initialization We use the Glorot initialization by Glorot and Bengio [2010]. Besides", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 241, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 506, + 253 + ], + "score": 1.0, + "content": "basic operations, it mainly involves generating a uniformly random fractional value in a given interval.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 93, + 273, + 207, + 286 + ], + "lines": [ + { + "bbox": [ + 89, + 271, + 209, + 290 + ], + "spans": [ + { + "bbox": [ + 89, + 271, + 209, + 290 + ], + "score": 1.0, + "content": "250 5 Implementation", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 92, + 300, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 90, + 301, + 506, + 314 + ], + "spans": [ + { + "bbox": [ + 90, + 304, + 100, + 313 + ], + "score": 1.0, + "content": "51", + "type": "text" + }, + { + "bbox": [ + 105, + 301, + 506, + 314 + ], + "score": 1.0, + "content": "We built our implementation on MP-SPDZ by Keller [2020]. MP-SPDZ not only implements a", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 90, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 90, + 315, + 99, + 323 + ], + "score": 1.0, + "content": "52", + "type": "text" + }, + { + "bbox": [ + 105, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "range of MPC protocols, it also comes with a high-level library containing the building blocks in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 89, + 322, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 89, + 326, + 100, + 335 + ], + "score": 1.0, + "content": "253", + "type": "text" + }, + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "score": 1.0, + "content": "Section 3. MP-SPDZ already featured capabilities to train dense neural networks as well as inference", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 89, + 332, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 89, + 336, + 100, + 345 + ], + "score": 1.0, + "content": "254", + "type": "text" + }, + { + "bbox": [ + 105, + 332, + 506, + 348 + ], + "score": 1.0, + "content": "for convolutional neural networks. We have added backward propagation for a number of layer types,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 89, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 89, + 348, + 100, + 357 + ], + "score": 1.0, + "content": "255", + "type": "text" + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "including 2D convolution. Furthermore, we have corrected a bug in the backward propagation for", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 89, + 355, + 162, + 370 + ], + "spans": [ + { + "bbox": [ + 89, + 358, + 100, + 367 + ], + "score": 1.0, + "content": "256", + "type": "text" + }, + { + "bbox": [ + 104, + 355, + 162, + 370 + ], + "score": 1.0, + "content": "dense layers.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 106, + 372, + 506, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "score": 1.0, + "content": "MP-SPDZ allows implementing the computation in Python code, which is then compiled a specific", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 384, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 506, + 396 + ], + "score": 1.0, + "content": "bytecode. This code can be execute by a virtual machine executing the actual secure computation.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 394, + 393, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 393, + 406 + ], + "score": 1.0, + "content": "The process allows to optimize the computation in the context of MPC.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 99, + 410, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "score": 1.0, + "content": "The framework also features an emulator that executes the exact computation that could be done", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 421, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 507, + 434 + ], + "score": 1.0, + "content": "securely in the clear. This allowed us to collect the accuracy figures in the next section at a lower cost.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 90, + 437, + 401, + 449 + ], + "lines": [ + { + "bbox": [ + 86, + 437, + 401, + 450 + ], + "spans": [ + { + "bbox": [ + 86, + 437, + 401, + 450 + ], + "score": 1.0, + "content": "262 It is licensed under a BSD-style license, which allows to extend the code.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 95, + 470, + 164, + 483 + ], + "lines": [ + { + "bbox": [ + 90, + 469, + 166, + 486 + ], + "spans": [ + { + "bbox": [ + 90, + 469, + 166, + 486 + ], + "score": 1.0, + "content": "63 6 MNIST", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 102, + 498, + 505, + 575 + ], + "lines": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "For a concrete measurement of accuracy and running times, we have implemented training for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "score": 1.0, + "content": "well-known MNIST dataset by LeCun et al. [2010]. We work mainly with the models that have been", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "score": 1.0, + "content": "used by Wagh et al. [2019] with secure computation, and we will reuse their numbering (A–D). The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 531, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 506, + 543 + ], + "score": 1.0, + "content": "models contain up to four linear layers. Network C is a convolutional neural network going back", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 506, + 554 + ], + "score": 1.0, + "content": "to the seminal work by LeCun et al. [1998] whereas the others are simpler networks that have been", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "score": 1.0, + "content": "proposed by works on secure computation such as Mohassel and Zhang [2017], Liu et al. [2017], and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 564, + 460, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 460, + 576 + ], + "score": 1.0, + "content": "Riazi et al. [2018]. We present the networks as Keras code in the supplemental material.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 105, + 579, + 505, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "Figure 2 shows the results for various quantization precisions and and the two rounding options.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 590, + 507, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 507, + 603 + ], + "score": 1.0, + "content": "We have used SGD with learning rate 0.01, batch size 128, and the usual MNIST training/test split.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 601, + 503, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 140, + 613 + ], + "score": 0.91, + "content": "f = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 601, + 415, + 614 + ], + "score": 1.0, + "content": "is the best option with probabilistic rounding, improving on both", + "type": "text" + }, + { + "bbox": [ + 416, + 602, + 450, + 613 + ], + "score": 0.91, + "content": "f = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 601, + 469, + 614 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 470, + 602, + 503, + 613 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 378, + 625 + ], + "score": 1.0, + "content": "Furthermore, nearest rounding performs worse that probabilistic for", + "type": "text" + }, + { + "bbox": [ + 378, + 613, + 408, + 624 + ], + "score": 0.92, + "content": "f = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 612, + 426, + 625 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 426, + 613, + 457, + 624 + ], + "score": 0.9, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 612, + 506, + 625 + ], + "score": 1.0, + "content": ". Due to the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 196, + 636 + ], + "score": 1.0, + "content": "high cost, we only ran", + "type": "text" + }, + { + "bbox": [ + 196, + 623, + 227, + 635 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "with probabilistic rounding several times. The range is indicate by the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 633, + 404, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 210, + 647 + ], + "score": 1.0, + "content": "shaded area. We focus on", + "type": "text" + }, + { + "bbox": [ + 211, + 635, + 241, + 646 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 633, + 404, + 647 + ], + "score": 1.0, + "content": "because it offers the faster convergence.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 103, + 650, + 505, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "Figure 3 then shows the result with a variety of optimizers. While increasing the learning rate for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 661, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 505, + 675 + ], + "score": 1.0, + "content": "SGD leads to a lower stability, Adam exposes a smoother learning learning curve albeit not a faster", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 674, + 141, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 141, + 685 + ], + "score": 1.0, + "content": "process.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 89, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 88, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 88, + 691, + 99, + 700 + ], + "score": 1.0, + "content": "280", + "type": "text" + }, + { + "bbox": [ + 104, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Finally, Figures 4 shows our results for all networks used by Wagh et al. [2019]. As one would expect,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 88, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 88, + 703, + 99, + 711 + ], + "score": 1.0, + "content": "281", + "type": "text" + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "the most sophisticated network performs best. Somewhat surprisingly, however, Network A (without", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 88, + 711, + 492, + 723 + ], + "spans": [ + { + "bbox": [ + 88, + 714, + 99, + 722 + ], + "score": 1.0, + "content": "282", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 492, + 723 + ], + "score": 1.0, + "content": "convolutional layers) performs better than the simpler networks containing convolutional layers.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "index", + "bbox": [ + 86, + 72, + 505, + 163 + ], + "lines": [], + "index": 3.5, + "bbox_fs": [ + 85, + 72, + 509, + 163 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 99, + 179, + 505, + 213 + ], + "lines": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "Adam The main difference to SGD in terms of basic computational operations is the additional", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "use of an inverse square root. We again defer the division by the batch size to just before the model", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 200, + 140, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 140, + 215 + ], + "score": 1.0, + "content": "update.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 179, + 505, + 215 + ] + }, + { + "type": "text", + "bbox": [ + 99, + 230, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 505, + 243 + ], + "score": 1.0, + "content": "Parameter initialization We use the Glorot initialization by Glorot and Bengio [2010]. Besides", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 241, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 506, + 253 + ], + "score": 1.0, + "content": "basic operations, it mainly involves generating a uniformly random fractional value in a given interval.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 229, + 506, + 253 + ] + }, + { + "type": "title", + "bbox": [ + 93, + 273, + 207, + 286 + ], + "lines": [ + { + "bbox": [ + 89, + 271, + 209, + 290 + ], + "spans": [ + { + "bbox": [ + 89, + 271, + 209, + 290 + ], + "score": 1.0, + "content": "250 5 Implementation", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "index", + "bbox": [ + 92, + 300, + 505, + 367 + ], + "lines": [ + { + "bbox": [ + 90, + 301, + 506, + 314 + ], + "spans": [ + { + "bbox": [ + 90, + 304, + 100, + 313 + ], + "score": 1.0, + "content": "51", + "type": "text" + }, + { + "bbox": [ + 105, + 301, + 506, + 314 + ], + "score": 1.0, + "content": "We built our implementation on MP-SPDZ by Keller [2020]. MP-SPDZ not only implements a", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 90, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 90, + 315, + 99, + 323 + ], + "score": 1.0, + "content": "52", + "type": "text" + }, + { + "bbox": [ + 105, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "range of MPC protocols, it also comes with a high-level library containing the building blocks in", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 322, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 89, + 326, + 100, + 335 + ], + "score": 1.0, + "content": "253", + "type": "text" + }, + { + "bbox": [ + 105, + 322, + 506, + 336 + ], + "score": 1.0, + "content": "Section 3. MP-SPDZ already featured capabilities to train dense neural networks as well as inference", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 332, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 89, + 336, + 100, + 345 + ], + "score": 1.0, + "content": "254", + "type": "text" + }, + { + "bbox": [ + 105, + 332, + 506, + 348 + ], + "score": 1.0, + "content": "for convolutional neural networks. We have added backward propagation for a number of layer types,", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 89, + 348, + 100, + 357 + ], + "score": 1.0, + "content": "255", + "type": "text" + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "including 2D convolution. Furthermore, we have corrected a bug in the backward propagation for", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 89, + 355, + 162, + 370 + ], + "spans": [ + { + "bbox": [ + 89, + 358, + 100, + 367 + ], + "score": 1.0, + "content": "256", + "type": "text" + }, + { + "bbox": [ + 104, + 355, + 162, + 370 + ], + "score": 1.0, + "content": "dense layers.", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + } + ], + "index": 16.5, + "bbox_fs": [ + 89, + 301, + 506, + 370 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 372, + 506, + 405 + ], + "lines": [ + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "score": 1.0, + "content": "MP-SPDZ allows implementing the computation in Python code, which is then compiled a specific", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 384, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 506, + 396 + ], + "score": 1.0, + "content": "bytecode. This code can be execute by a virtual machine executing the actual secure computation.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 394, + 393, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 393, + 406 + ], + "score": 1.0, + "content": "The process allows to optimize the computation in the context of MPC.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 372, + 506, + 406 + ] + }, + { + "type": "text", + "bbox": [ + 99, + 410, + 505, + 433 + ], + "lines": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 411, + 505, + 422 + ], + "score": 1.0, + "content": "The framework also features an emulator that executes the exact computation that could be done", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 421, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 507, + 434 + ], + "score": 1.0, + "content": "securely in the clear. This allowed us to collect the accuracy figures in the next section at a lower cost.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 411, + 507, + 434 + ] + }, + { + "type": "text", + "bbox": [ + 90, + 437, + 401, + 449 + ], + "lines": [ + { + "bbox": [ + 86, + 437, + 401, + 450 + ], + "spans": [ + { + "bbox": [ + 86, + 437, + 401, + 450 + ], + "score": 1.0, + "content": "262 It is licensed under a BSD-style license, which allows to extend the code.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25, + "bbox_fs": [ + 86, + 437, + 401, + 450 + ] + }, + { + "type": "title", + "bbox": [ + 95, + 470, + 164, + 483 + ], + "lines": [ + { + "bbox": [ + 90, + 469, + 166, + 486 + ], + "spans": [ + { + "bbox": [ + 90, + 469, + 166, + 486 + ], + "score": 1.0, + "content": "63 6 MNIST", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 102, + 498, + 505, + 575 + ], + "lines": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 505, + 510 + ], + "score": 1.0, + "content": "For a concrete measurement of accuracy and running times, we have implemented training for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 506, + 521 + ], + "score": 1.0, + "content": "well-known MNIST dataset by LeCun et al. [2010]. We work mainly with the models that have been", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 506, + 532 + ], + "score": 1.0, + "content": "used by Wagh et al. [2019] with secure computation, and we will reuse their numbering (A–D). The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 531, + 506, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 506, + 543 + ], + "score": 1.0, + "content": "models contain up to four linear layers. Network C is a convolutional neural network going back", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 506, + 554 + ], + "score": 1.0, + "content": "to the seminal work by LeCun et al. [1998] whereas the others are simpler networks that have been", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 564 + ], + "score": 1.0, + "content": "proposed by works on secure computation such as Mohassel and Zhang [2017], Liu et al. [2017], and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 564, + 460, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 460, + 576 + ], + "score": 1.0, + "content": "Riazi et al. [2018]. We present the networks as Keras code in the supplemental material.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 498, + 506, + 576 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 579, + 505, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "Figure 2 shows the results for various quantization precisions and and the two rounding options.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 590, + 507, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 507, + 603 + ], + "score": 1.0, + "content": "We have used SGD with learning rate 0.01, batch size 128, and the usual MNIST training/test split.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 601, + 503, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 602, + 140, + 613 + ], + "score": 0.91, + "content": "f = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 601, + 415, + 614 + ], + "score": 1.0, + "content": "is the best option with probabilistic rounding, improving on both", + "type": "text" + }, + { + "bbox": [ + 416, + 602, + 450, + 613 + ], + "score": 0.91, + "content": "f = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 601, + 469, + 614 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 470, + 602, + 503, + 613 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 378, + 625 + ], + "score": 1.0, + "content": "Furthermore, nearest rounding performs worse that probabilistic for", + "type": "text" + }, + { + "bbox": [ + 378, + 613, + 408, + 624 + ], + "score": 0.92, + "content": "f = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 612, + 426, + 625 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 426, + 613, + 457, + 624 + ], + "score": 0.9, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 612, + 506, + 625 + ], + "score": 1.0, + "content": ". Due to the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 196, + 636 + ], + "score": 1.0, + "content": "high cost, we only ran", + "type": "text" + }, + { + "bbox": [ + 196, + 623, + 227, + 635 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "with probabilistic rounding several times. The range is indicate by the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 633, + 404, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 210, + 647 + ], + "score": 1.0, + "content": "shaded area. We focus on", + "type": "text" + }, + { + "bbox": [ + 211, + 635, + 241, + 646 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 633, + 404, + 647 + ], + "score": 1.0, + "content": "because it offers the faster convergence.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 579, + 507, + 647 + ] + }, + { + "type": "text", + "bbox": [ + 103, + 650, + 505, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "Figure 3 then shows the result with a variety of optimizers. While increasing the learning rate for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 661, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 505, + 675 + ], + "score": 1.0, + "content": "SGD leads to a lower stability, Adam exposes a smoother learning learning curve albeit not a faster", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 674, + 141, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 141, + 685 + ], + "score": 1.0, + "content": "process.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 649, + 505, + 685 + ] + }, + { + "type": "index", + "bbox": [ + 89, + 689, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 88, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 88, + 691, + 99, + 700 + ], + "score": 1.0, + "content": "280", + "type": "text" + }, + { + "bbox": [ + 104, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Finally, Figures 4 shows our results for all networks used by Wagh et al. [2019]. As one would expect,", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 88, + 703, + 99, + 711 + ], + "score": 1.0, + "content": "281", + "type": "text" + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "the most sophisticated network performs best. Somewhat surprisingly, however, Network A (without", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 88, + 711, + 492, + 723 + ], + "spans": [ + { + "bbox": [ + 88, + 714, + 99, + 722 + ], + "score": 1.0, + "content": "282", + "type": "text" + }, + { + "bbox": [ + 105, + 711, + 492, + 723 + ], + "score": 1.0, + "content": "convolutional layers) performs better than the simpler networks containing convolutional layers.", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + } + ], + "index": 44, + "bbox_fs": [ + 88, + 688, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 124, + 69, + 488, + 261 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 124, + 69, + 488, + 261 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 124, + 69, + 488, + 261 + ], + "spans": [ + { + "bbox": [ + 124, + 69, + 488, + 261 + ], + "score": 0.956, + "type": "image", + "image_path": "3a38cf90fbe641b15f4921c674ee686f614e2a42472767f16d74facf9f248ace.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 124, + 69, + 488, + 133.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 124, + 133.0, + 488, + 197.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 124, + 197.0, + 488, + 261.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 272, + 505, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 271, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 507, + 286 + ], + "score": 1.0, + "content": "Figure 2: Loss and accuracy for network C and precision options when running SGD with rate 0.01.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 121, + 297, + 473, + 489 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 121, + 297, + 473, + 489 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 121, + 297, + 473, + 489 + ], + "spans": [ + { + "bbox": [ + 121, + 297, + 473, + 489 + ], + "score": 0.695, + "type": "image", + "image_path": "ca865aaa95abbc18690e028b3ca52b226046ffa5e278339ad08eb557c5491c91.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 121, + 297, + 473, + 361.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 121, + 361.0, + 473, + 425.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 121, + 425.0, + 473, + 489.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 501, + 504, + 523 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 402, + 514 + ], + "score": 1.0, + "content": "Figure 3: Loss and accuracy for network C with various optimizer options,", + "type": "text" + }, + { + "bbox": [ + 403, + 501, + 433, + 513 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 500, + 506, + 514 + ], + "score": 1.0, + "content": ", and probabilistic", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 511, + 151, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 151, + 523 + ], + "score": 1.0, + "content": "truncation.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + } + ], + "index": 6.25 + }, + { + "type": "text", + "bbox": [ + 102, + 546, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "score": 1.0, + "content": "Resources We ran the emulator on AWS c5.9xlarge instances. One epoch takes a few second to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "score": 1.0, + "content": "several minutes depending on the model. Overall, we estimate that we have used a few weeks worth", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 568, + 460, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 460, + 580 + ], + "score": 1.0, + "content": "of computing time including experiments not included here because of bugs in the code.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 107, + 596, + 215, + 608 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 216, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 216, + 610 + ], + "score": 1.0, + "content": "6.1 Secure computation", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 618, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 449, + 631 + ], + "score": 1.0, + "content": "In order to verify our emulation results, we have run Network C with precision", + "type": "text" + }, + { + "bbox": [ + 449, + 619, + 486, + 630 + ], + "score": 0.91, + "content": "f \\ = \\ 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 630, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 506, + 642 + ], + "score": 1.0, + "content": "probabilistic rounding in our actual multi-party computation protocol. We could verify that it", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 159, + 653 + ], + "score": 1.0, + "content": "converges on", + "type": "text" + }, + { + "bbox": [ + 160, + 640, + 187, + 651 + ], + "score": 0.87, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "accuracy at 150 epochs, taking 20 hours. Table 2 compares our result to previous", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "works in a LAN setting. Note that Wagh et al. [2019] and Wagh et al. [2021] give accuracy figures.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 661, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 506, + 675 + ], + "score": 1.0, + "content": "From personal communication with the authors and the fact that the source repository for the latter", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "score": 1.0, + "content": "work2 says that their “code has not run end-to-end training”, we derive our assessment that their", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 684, + 288, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 288, + 696 + ], + "score": 1.0, + "content": "figures do not reflect the secure computation.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 712, + 308, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 309, + 725 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 309, + 725 + ], + "score": 1.0, + "content": "2https://github.com/snwagh/falcon-public", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 124, + 69, + 488, + 261 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 124, + 69, + 488, + 261 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 124, + 69, + 488, + 261 + ], + "spans": [ + { + "bbox": [ + 124, + 69, + 488, + 261 + ], + "score": 0.956, + "type": "image", + "image_path": "3a38cf90fbe641b15f4921c674ee686f614e2a42472767f16d74facf9f248ace.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 124, + 69, + 488, + 133.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 124, + 133.0, + 488, + 197.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 124, + 197.0, + 488, + 261.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 272, + 505, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 271, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 507, + 286 + ], + "score": 1.0, + "content": "Figure 2: Loss and accuracy for network C and precision options when running SGD with rate 0.01.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 121, + 297, + 473, + 489 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 121, + 297, + 473, + 489 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 121, + 297, + 473, + 489 + ], + "spans": [ + { + "bbox": [ + 121, + 297, + 473, + 489 + ], + "score": 0.695, + "type": "image", + "image_path": "ca865aaa95abbc18690e028b3ca52b226046ffa5e278339ad08eb557c5491c91.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 121, + 297, + 473, + 361.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 121, + 361.0, + 473, + 425.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 121, + 425.0, + 473, + 489.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 501, + 504, + 523 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 402, + 514 + ], + "score": 1.0, + "content": "Figure 3: Loss and accuracy for network C with various optimizer options,", + "type": "text" + }, + { + "bbox": [ + 403, + 501, + 433, + 513 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 500, + 506, + 514 + ], + "score": 1.0, + "content": ", and probabilistic", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 511, + 151, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 151, + 523 + ], + "score": 1.0, + "content": "truncation.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + } + ], + "index": 6.25 + }, + { + "type": "text", + "bbox": [ + 102, + 546, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "score": 1.0, + "content": "Resources We ran the emulator on AWS c5.9xlarge instances. One epoch takes a few second to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 557, + 505, + 569 + ], + "score": 1.0, + "content": "several minutes depending on the model. Overall, we estimate that we have used a few weeks worth", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 568, + 460, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 460, + 580 + ], + "score": 1.0, + "content": "of computing time including experiments not included here because of bugs in the code.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 106, + 545, + 506, + 580 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 596, + 215, + 608 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 216, + 610 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 216, + 610 + ], + "score": 1.0, + "content": "6.1 Secure computation", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 618, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 449, + 631 + ], + "score": 1.0, + "content": "In order to verify our emulation results, we have run Network C with precision", + "type": "text" + }, + { + "bbox": [ + 449, + 619, + 486, + 630 + ], + "score": 0.91, + "content": "f \\ = \\ 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 630, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 506, + 642 + ], + "score": 1.0, + "content": "probabilistic rounding in our actual multi-party computation protocol. We could verify that it", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 159, + 653 + ], + "score": 1.0, + "content": "converges on", + "type": "text" + }, + { + "bbox": [ + 160, + 640, + 187, + 651 + ], + "score": 0.87, + "content": "9 8 . 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "accuracy at 150 epochs, taking 20 hours. Table 2 compares our result to previous", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 650, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 506, + 664 + ], + "score": 1.0, + "content": "works in a LAN setting. Note that Wagh et al. [2019] and Wagh et al. [2021] give accuracy figures.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 661, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 506, + 675 + ], + "score": 1.0, + "content": "From personal communication with the authors and the fact that the source repository for the latter", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "score": 1.0, + "content": "work2 says that their “code has not run end-to-end training”, we derive our assessment that their", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 684, + 288, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 288, + 696 + ], + "score": 1.0, + "content": "figures do not reflect the secure computation.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 618, + 506, + 696 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 133, + 69, + 480, + 261 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 133, + 69, + 480, + 261 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 133, + 69, + 480, + 261 + ], + "spans": [ + { + "bbox": [ + 133, + 69, + 480, + 261 + ], + "score": 0.965, + "type": "image", + "image_path": "700a37281e56f21023ee263453c7785f933f7176bea7c10046675acc845cf598.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 133, + 69, + 480, + 133.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 133, + 133.0, + 480, + 197.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 133, + 197.0, + 480, + 261.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 130, + 272, + 480, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 272, + 481, + 286 + ], + "spans": [ + { + "bbox": [ + 129, + 272, + 332, + 286 + ], + "score": 1.0, + "content": "Figure 4: Loss and accuracy for various networks,", + "type": "text" + }, + { + "bbox": [ + 333, + 273, + 363, + 285 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 272, + 481, + 286 + ], + "score": 1.0, + "content": ", and probabilistic truncation.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "table", + "bbox": [ + 112, + 356, + 499, + 604 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 305, + 505, + 350 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 354, + 318 + ], + "score": 1.0, + "content": "Table 2: Comparison to previous work in the LAN setting.", + "type": "text" + }, + { + "bbox": [ + 354, + 306, + 367, + 317 + ], + "score": 0.7, + "content": "( ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 305, + 506, + 318 + ], + "score": 1.0, + "content": "Mohassel and Zhang [2017] and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 317, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 506, + 329 + ], + "score": 1.0, + "content": "Agrawal et al. [2019] use a different security model and are thus incomparable. We include them for", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "score": 1.0, + "content": "completeness. Two numbers refer to online and offline time. Accuracy N/A means that the accuracy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 339, + 464, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 464, + 351 + ], + "score": 1.0, + "content": "figures were not given or computed in a way that does not reflect the secure computation.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "table_body", + "bbox": [ + 112, + 356, + 499, + 604 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 356, + 499, + 604 + ], + "spans": [ + { + "bbox": [ + 112, + 356, + 499, + 604 + ], + "score": 0.986, + "html": "
NetworkEpoch time (s)Acc. (# epochs)Precision(f)
AMohassel and Zhang [2017]283/19333*93.4% (15)13
Mohassel and Rindal [2018]18094.0% (15)N/A
Agrawal et al. [2019]31392*95.0% (10)N/A
Wagh et al. [2019]247N/A13
Wagh et al. [2021]41N/A13
Ours3197.9% (15)16
Ours5097.7% (15)32
BWagh et al. [2019]4176N/A13
Wagh et al. [2021]101N/A13
Ours14493.6% (15)16
Ours24994.7% (15)32
CWagh et al. [2019]7188N/A13
Wagh et al. [2021]891N/A13
Tan et al. [2021]103694.0% (5)20
Ours34494.9% (5)16
Ours64393.8% (5)32
DMohassel and Rindal [2018]234N/AN/A
Ours4196.8% (15)16
Ours6896.8% (15)32
", + "type": "table", + "image_path": "97abf13640224b2e7ab8627c268f2fab07076453ba8f2fc10f4cc1bc2f920aae.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 112, + 356, + 499, + 438.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 112, + 438.6666666666667, + 499, + 521.3333333333334 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 112, + 521.3333333333334, + 499, + 604.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.25 + }, + { + "type": "title", + "bbox": [ + 86, + 634, + 188, + 648 + ], + "lines": [ + { + "bbox": [ + 84, + 632, + 189, + 650 + ], + "spans": [ + { + "bbox": [ + 84, + 632, + 189, + 650 + ], + "score": 1.0, + "content": "294 7 Conclusions", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 86, + 667, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 86, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 100, + 678 + ], + "score": 1.0, + "content": "295", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "We have presented an implementation of deep learning training purely in multi-party computation", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 86, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 100, + 689 + ], + "score": 1.0, + "content": "296", + "type": "text" + }, + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "with extensive results on the accuracy. We have found that the lower precision of MPC computation", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 86, + 688, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 100, + 700 + ], + "score": 1.0, + "content": "297", + "type": "text" + }, + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "score": 1.0, + "content": "increases the error considerably. We only have considered one particular implementation of more", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 86, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 100, + 711 + ], + "score": 1.0, + "content": "298", + "type": "text" + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "complex computation such as division and exponentiation, which are crucial to the learning process", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 86, + 710, + 498, + 723 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 100, + 722 + ], + "score": 1.0, + "content": "299", + "type": "text" + }, + { + "bbox": [ + 104, + 710, + 498, + 723 + ], + "score": 1.0, + "content": "as part of softmax. Future work might consider different approximations of these building blocks.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 133, + 69, + 480, + 261 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 133, + 69, + 480, + 261 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 133, + 69, + 480, + 261 + ], + "spans": [ + { + "bbox": [ + 133, + 69, + 480, + 261 + ], + "score": 0.965, + "type": "image", + "image_path": "700a37281e56f21023ee263453c7785f933f7176bea7c10046675acc845cf598.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 133, + 69, + 480, + 133.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 133, + 133.0, + 480, + 197.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 133, + 197.0, + 480, + 261.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 130, + 272, + 480, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 272, + 481, + 286 + ], + "spans": [ + { + "bbox": [ + 129, + 272, + 332, + 286 + ], + "score": 1.0, + "content": "Figure 4: Loss and accuracy for various networks,", + "type": "text" + }, + { + "bbox": [ + 333, + 273, + 363, + 285 + ], + "score": 0.91, + "content": "f = 3 2", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 272, + 481, + 286 + ], + "score": 1.0, + "content": ", and probabilistic truncation.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "table", + "bbox": [ + 112, + 356, + 499, + 604 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 305, + 505, + 350 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 354, + 318 + ], + "score": 1.0, + "content": "Table 2: Comparison to previous work in the LAN setting.", + "type": "text" + }, + { + "bbox": [ + 354, + 306, + 367, + 317 + ], + "score": 0.7, + "content": "( ^ { * } )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 305, + 506, + 318 + ], + "score": 1.0, + "content": "Mohassel and Zhang [2017] and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 317, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 506, + 329 + ], + "score": 1.0, + "content": "Agrawal et al. [2019] use a different security model and are thus incomparable. We include them for", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 341 + ], + "score": 1.0, + "content": "completeness. Two numbers refer to online and offline time. Accuracy N/A means that the accuracy", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 339, + 464, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 464, + 351 + ], + "score": 1.0, + "content": "figures were not given or computed in a way that does not reflect the secure computation.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "table_body", + "bbox": [ + 112, + 356, + 499, + 604 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 356, + 499, + 604 + ], + "spans": [ + { + "bbox": [ + 112, + 356, + 499, + 604 + ], + "score": 0.986, + "html": "
NetworkEpoch time (s)Acc. (# epochs)Precision(f)
AMohassel and Zhang [2017]283/19333*93.4% (15)13
Mohassel and Rindal [2018]18094.0% (15)N/A
Agrawal et al. [2019]31392*95.0% (10)N/A
Wagh et al. [2019]247N/A13
Wagh et al. [2021]41N/A13
Ours3197.9% (15)16
Ours5097.7% (15)32
BWagh et al. [2019]4176N/A13
Wagh et al. [2021]101N/A13
Ours14493.6% (15)16
Ours24994.7% (15)32
CWagh et al. [2019]7188N/A13
Wagh et al. [2021]891N/A13
Tan et al. [2021]103694.0% (5)20
Ours34494.9% (5)16
Ours64393.8% (5)32
DMohassel and Rindal [2018]234N/AN/A
Ours4196.8% (15)16
Ours6896.8% (15)32
", + "type": "table", + "image_path": "97abf13640224b2e7ab8627c268f2fab07076453ba8f2fc10f4cc1bc2f920aae.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 112, + 356, + 499, + 438.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 112, + 438.6666666666667, + 499, + 521.3333333333334 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 112, + 521.3333333333334, + 499, + 604.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.25 + }, + { + "type": "title", + "bbox": [ + 86, + 634, + 188, + 648 + ], + "lines": [ + { + "bbox": [ + 84, + 632, + 189, + 650 + ], + "spans": [ + { + "bbox": [ + 84, + 632, + 189, + 650 + ], + "score": 1.0, + "content": "294 7 Conclusions", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "index", + "bbox": [ + 86, + 667, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 86, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 86, + 669, + 100, + 678 + ], + "score": 1.0, + "content": "295", + "type": "text" + }, + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "We have presented an implementation of deep learning training purely in multi-party computation", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 678, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 86, + 680, + 100, + 689 + ], + "score": 1.0, + "content": "296", + "type": "text" + }, + { + "bbox": [ + 106, + 678, + 505, + 690 + ], + "score": 1.0, + "content": "with extensive results on the accuracy. We have found that the lower precision of MPC computation", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 688, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 86, + 691, + 100, + 700 + ], + "score": 1.0, + "content": "297", + "type": "text" + }, + { + "bbox": [ + 105, + 688, + 505, + 702 + ], + "score": 1.0, + "content": "increases the error considerably. We only have considered one particular implementation of more", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 86, + 702, + 100, + 711 + ], + "score": 1.0, + "content": "298", + "type": "text" + }, + { + "bbox": [ + 105, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "complex computation such as division and exponentiation, which are crucial to the learning process", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 710, + 498, + 723 + ], + "spans": [ + { + "bbox": [ + 86, + 713, + 100, + 722 + ], + "score": 1.0, + "content": "299", + "type": "text" + }, + { + "bbox": [ + 104, + 710, + 498, + 723 + ], + "score": 1.0, + "content": "as part of softmax. Future work might consider different approximations of these building blocks.", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + } + ], + "index": 14, + "bbox_fs": [ + 86, + 666, + 505, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 92, + 72, + 164, + 84 + ], + "lines": [ + { + "bbox": [ + 92, + 72, + 164, + 84 + ], + "spans": [], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 86, + 75, + 508, + 728 + ], + "lines": [ + { + "bbox": [ + 90, + 71, + 165, + 86 + ], + "spans": [ + { + "bbox": [ + 90, + 71, + 165, + 86 + ], + "score": 1.0, + "content": "00 References", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 84, + 91, + 506, + 104 + ], + "spans": [ + { + "bbox": [ + 84, + 91, + 101, + 104 + ], + "score": 1.0, + "content": "301", + "type": "text" + }, + { + "bbox": [ + 104, + 91, + 506, + 104 + ], + "score": 1.0, + "content": "N. Agrawal, A. S. Shamsabadi, M. J. Kusner, and A. Gascón. QUOTIENT: Two-party secure neural", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 84, + 101, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 84, + 103, + 101, + 115 + ], + "score": 1.0, + "content": "302", + "type": "text" + }, + { + "bbox": [ + 114, + 101, + 506, + 115 + ], + "score": 1.0, + "content": "network training and prediction. In L. Cavallaro, J. Kinder, X. Wang, and J. Katz, editors, ACM", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 85, + 113, + 466, + 126 + ], + "spans": [ + { + "bbox": [ + 85, + 114, + 100, + 126 + ], + "score": 1.0, + "content": "303", + "type": "text" + }, + { + "bbox": [ + 115, + 113, + 466, + 126 + ], + "score": 1.0, + "content": "CCS 2019, pages 1231–1247. ACM Press, Nov. 2019. doi: 10.1145/3319535.3339819.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 85, + 132, + 507, + 148 + ], + "spans": [ + { + "bbox": [ + 85, + 135, + 101, + 146 + ], + "score": 1.0, + "content": "304", + "type": "text" + }, + { + "bbox": [ + 104, + 132, + 507, + 148 + ], + "score": 1.0, + "content": "M. Aliasgari, M. Blanton, Y. Zhang, and A. Steele. Secure computation on floating point numbers.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 85, + 144, + 309, + 157 + ], + "spans": [ + { + "bbox": [ + 85, + 146, + 100, + 157 + ], + "score": 1.0, + "content": "305", + "type": "text" + }, + { + "bbox": [ + 114, + 144, + 309, + 157 + ], + "score": 1.0, + "content": "In NDSS 2013. The Internet Society, Feb. 2013.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 85, + 162, + 507, + 180 + ], + "spans": [ + { + "bbox": [ + 85, + 166, + 101, + 177 + ], + "score": 1.0, + "content": "306", + "type": "text" + }, + { + "bbox": [ + 102, + 162, + 507, + 180 + ], + "score": 1.0, + "content": "A. Aly and N. P. Smart. Benchmarking privacy preserving scientific operations. In R. H. Deng,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 85, + 174, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 85, + 177, + 100, + 188 + ], + "score": 1.0, + "content": "307", + "type": "text" + }, + { + "bbox": [ + 114, + 174, + 506, + 190 + ], + "score": 1.0, + "content": "V. Gauthier-Umaña, M. Ochoa, and M. Yung, editors, ACNS 19, volume 11464 of LNCS, pages", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 85, + 185, + 446, + 201 + ], + "spans": [ + { + "bbox": [ + 85, + 187, + 100, + 199 + ], + "score": 1.0, + "content": "308", + "type": "text" + }, + { + "bbox": [ + 115, + 185, + 446, + 201 + ], + "score": 1.0, + "content": "509–529. Springer, Heidelberg, June 2019. doi: 10.1007/978-3-030-21568-2_25.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 85, + 205, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 85, + 208, + 101, + 218 + ], + "score": 1.0, + "content": "309", + "type": "text" + }, + { + "bbox": [ + 104, + 205, + 506, + 220 + ], + "score": 1.0, + "content": "T. Araki, J. Furukawa, Y. Lindell, A. Nof, and K. Ohara. High-throughput semi-honest secure", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 85, + 216, + 507, + 232 + ], + "spans": [ + { + "bbox": [ + 85, + 218, + 100, + 230 + ], + "score": 1.0, + "content": "310", + "type": "text" + }, + { + "bbox": [ + 114, + 216, + 507, + 232 + ], + "score": 1.0, + "content": "three-party computation with an honest majority. In E. R. Weippl, S. Katzenbeisser, C. Kruegel,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 85, + 227, + 507, + 242 + ], + "spans": [ + { + "bbox": [ + 85, + 230, + 100, + 241 + ], + "score": 1.0, + "content": "311", + "type": "text" + }, + { + "bbox": [ + 113, + 227, + 507, + 242 + ], + "score": 1.0, + "content": "A. C. Myers, and S. Halevi, editors, ACM CCS 2016, pages 805–817. ACM Press, Oct. 2016. doi:", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 85, + 238, + 229, + 252 + ], + "spans": [ + { + "bbox": [ + 85, + 240, + 100, + 252 + ], + "score": 1.0, + "content": "312", + "type": "text" + }, + { + "bbox": [ + 115, + 238, + 229, + 252 + ], + "score": 1.0, + "content": "10.1145/2976749.2978331.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 84, + 255, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 84, + 260, + 101, + 273 + ], + "score": 1.0, + "content": "313", + "type": "text" + }, + { + "bbox": [ + 102, + 255, + 506, + 275 + ], + "score": 1.0, + "content": "T. Araki, A. Barak, J. Furukawa, M. Keller, Y. Lindell, K. Ohara, and H. Tsuchida. Generalizing", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 84, + 268, + 507, + 285 + ], + "spans": [ + { + "bbox": [ + 84, + 271, + 101, + 284 + ], + "score": 1.0, + "content": "314", + "type": "text" + }, + { + "bbox": [ + 114, + 268, + 507, + 285 + ], + "score": 1.0, + "content": "the SPDZ compiler for other protocols. In D. Lie, M. Mannan, M. Backes, and X. Wang, editors,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 85, + 280, + 478, + 295 + ], + "spans": [ + { + "bbox": [ + 85, + 283, + 100, + 294 + ], + "score": 1.0, + "content": "315", + "type": "text" + }, + { + "bbox": [ + 112, + 280, + 478, + 295 + ], + "score": 1.0, + "content": "ACM CCS 2018, pages 880–895. ACM Press, Oct. 2018. doi: 10.1145/3243734.3243854.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 85, + 300, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 85, + 303, + 101, + 314 + ], + "score": 1.0, + "content": "316", + "type": "text" + }, + { + "bbox": [ + 104, + 300, + 506, + 316 + ], + "score": 1.0, + "content": "M. Barni, C. Orlandi, and A. Piva. A privacy-preserving protocol for neural-network-based computa-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 85, + 312, + 487, + 326 + ], + "spans": [ + { + "bbox": [ + 85, + 314, + 100, + 325 + ], + "score": 1.0, + "content": "317", + "type": "text" + }, + { + "bbox": [ + 115, + 312, + 487, + 326 + ], + "score": 1.0, + "content": "tion. In Proceedings of the 8th workshop on Multimedia and security, pages 146–151, 2006.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 85, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 85, + 334, + 101, + 344 + ], + "score": 1.0, + "content": "318", + "type": "text" + }, + { + "bbox": [ + 103, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "J. C. Benaloh and J. Leichter. Generalized secret sharing and monotone functions. In S. Goldwasser,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 85, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 85, + 344, + 100, + 356 + ], + "score": 1.0, + "content": "319", + "type": "text" + }, + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "editor, CRYPTO’88, volume 403 of LNCS, pages 27–35. Springer, Heidelberg, Aug. 1990. doi:", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 85, + 354, + 227, + 367 + ], + "spans": [ + { + "bbox": [ + 85, + 355, + 100, + 367 + ], + "score": 1.0, + "content": "320", + "type": "text" + }, + { + "bbox": [ + 114, + 354, + 227, + 367 + ], + "score": 1.0, + "content": "10.1007/0-387-34799-2_3.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 85, + 374, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 85, + 376, + 101, + 387 + ], + "score": 1.0, + "content": "321", + "type": "text" + }, + { + "bbox": [ + 105, + 374, + 506, + 388 + ], + "score": 1.0, + "content": "O. Catrina and A. Saxena. Secure computation with fixed-point numbers. In R. Sion, editor, FC", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 85, + 385, + 422, + 399 + ], + "spans": [ + { + "bbox": [ + 85, + 387, + 100, + 398 + ], + "score": 1.0, + "content": "322", + "type": "text" + }, + { + "bbox": [ + 115, + 385, + 422, + 399 + ], + "score": 1.0, + "content": "2010, volume 6052 of LNCS, pages 35–50. Springer, Heidelberg, Jan. 2010.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 84, + 406, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 84, + 406, + 101, + 419 + ], + "score": 1.0, + "content": "323", + "type": "text" + }, + { + "bbox": [ + 105, + 406, + 506, + 419 + ], + "score": 1.0, + "content": "M. Dahl, J. Mancuso, Y. Dupis, B. Decoste, M. Giraud, I. Livingstone, J. Patriquin, and G. Uhma.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 85, + 416, + 508, + 432 + ], + "spans": [ + { + "bbox": [ + 85, + 418, + 100, + 429 + ], + "score": 1.0, + "content": "324", + "type": "text" + }, + { + "bbox": [ + 114, + 416, + 508, + 432 + ], + "score": 1.0, + "content": "Private machine learning in tensorflow using secure computation. CoRR, abs/1810.08130, 2018.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 85, + 428, + 307, + 442 + ], + "spans": [ + { + "bbox": [ + 85, + 429, + 100, + 441 + ], + "score": 1.0, + "content": "325", + "type": "text" + }, + { + "bbox": [ + 116, + 428, + 307, + 442 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1810.08130.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 85, + 447, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 85, + 450, + 101, + 460 + ], + "score": 1.0, + "content": "326", + "type": "text" + }, + { + "bbox": [ + 104, + 447, + 506, + 462 + ], + "score": 1.0, + "content": "A. Dalskov, D. Escudero, and M. Keller. Fantastic four: Honest-majority four-party secure com-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 85, + 457, + 507, + 474 + ], + "spans": [ + { + "bbox": [ + 85, + 460, + 100, + 471 + ], + "score": 1.0, + "content": "327", + "type": "text" + }, + { + "bbox": [ + 114, + 457, + 507, + 474 + ], + "score": 1.0, + "content": "putation with malicious security. In 30th USENIX Security Symposium (USENIX Security 21),", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 85, + 468, + 142, + 483 + ], + "spans": [ + { + "bbox": [ + 85, + 471, + 100, + 482 + ], + "score": 1.0, + "content": "328", + "type": "text" + }, + { + "bbox": [ + 114, + 468, + 142, + 483 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 84, + 489, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 84, + 490, + 101, + 503 + ], + "score": 1.0, + "content": "329", + "type": "text" + }, + { + "bbox": [ + 104, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "A. P. K. Dalskov, D. Escudero, and M. Keller. Secure evaluation of quantized neural networks.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 85, + 499, + 406, + 515 + ], + "spans": [ + { + "bbox": [ + 85, + 502, + 100, + 513 + ], + "score": 1.0, + "content": "330", + "type": "text" + }, + { + "bbox": [ + 114, + 499, + 406, + 515 + ], + "score": 1.0, + "content": "PoPETs, 2020(4):355–375, Oct. 2020. doi: 10.2478/popets-2020-0077.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 85, + 520, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 85, + 523, + 101, + 533 + ], + "score": 1.0, + "content": "331", + "type": "text" + }, + { + "bbox": [ + 104, + 520, + 506, + 536 + ], + "score": 1.0, + "content": "I. Damgård, M. Fitzi, E. Kiltz, J. B. Nielsen, and T. Toft. Unconditionally secure constant-rounds", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 85, + 531, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 85, + 533, + 100, + 545 + ], + "score": 1.0, + "content": "332", + "type": "text" + }, + { + "bbox": [ + 114, + 531, + 506, + 547 + ], + "score": 1.0, + "content": "multi-party computation for equality, comparison, bits and exponentiation. In S. Halevi and", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 85, + 542, + 507, + 558 + ], + "spans": [ + { + "bbox": [ + 85, + 544, + 100, + 556 + ], + "score": 1.0, + "content": "333", + "type": "text" + }, + { + "bbox": [ + 114, + 542, + 507, + 558 + ], + "score": 1.0, + "content": "T. Rabin, editors, TCC 2006, volume 3876 of LNCS, pages 285–304. Springer, Heidelberg, Mar.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 85, + 554, + 258, + 567 + ], + "spans": [ + { + "bbox": [ + 85, + 555, + 100, + 567 + ], + "score": 1.0, + "content": "334", + "type": "text" + }, + { + "bbox": [ + 115, + 554, + 258, + 567 + ], + "score": 1.0, + "content": "2006. doi: 10.1007/11681878_15.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 85, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 85, + 575, + 101, + 586 + ], + "score": 1.0, + "content": "335", + "type": "text" + }, + { + "bbox": [ + 104, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "I. Damgård, D. Escudero, T. K. Frederiksen, M. Keller, P. Scholl, and N. Volgushev. New primitives", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 85, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 85, + 586, + 100, + 598 + ], + "score": 1.0, + "content": "336", + "type": "text" + }, + { + "bbox": [ + 115, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "for actively-secure MPC over rings with applications to private machine learning. In 2019 IEEE", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 85, + 595, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 85, + 597, + 100, + 609 + ], + "score": 1.0, + "content": "337", + "type": "text" + }, + { + "bbox": [ + 114, + 595, + 506, + 611 + ], + "score": 1.0, + "content": "Symposium on Security and Privacy, pages 1102–1120. IEEE Computer Society Press, May 2019.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 85, + 606, + 235, + 619 + ], + "spans": [ + { + "bbox": [ + 85, + 608, + 100, + 619 + ], + "score": 1.0, + "content": "338", + "type": "text" + }, + { + "bbox": [ + 115, + 606, + 235, + 619 + ], + "score": 1.0, + "content": "doi: 10.1109/SP.2019.00078.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 84, + 625, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 84, + 627, + 101, + 640 + ], + "score": 1.0, + "content": "339", + "type": "text" + }, + { + "bbox": [ + 104, + 625, + 506, + 641 + ], + "score": 1.0, + "content": "H. Eerikson, M. Keller, C. Orlandi, P. Pullonen, J. Puura, and M. Simkin. Use your brain! Arithmetic", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 84, + 637, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 84, + 639, + 101, + 652 + ], + "score": 1.0, + "content": "340", + "type": "text" + }, + { + "bbox": [ + 114, + 637, + 506, + 653 + ], + "score": 1.0, + "content": "3PC for any modulus with active security. In Y. T. Kalai, A. D. Smith, and D. Wichs, editors, ITC", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 85, + 648, + 461, + 663 + ], + "spans": [ + { + "bbox": [ + 85, + 650, + 100, + 661 + ], + "score": 1.0, + "content": "341", + "type": "text" + }, + { + "bbox": [ + 114, + 648, + 461, + 663 + ], + "score": 1.0, + "content": "2020, pages 5:1–5:24. Schloss Dagstuhl, June 2020. doi: 10.4230/LIPIcs.ITC.2020.5.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 85, + 668, + 507, + 684 + ], + "spans": [ + { + "bbox": [ + 85, + 671, + 101, + 681 + ], + "score": 1.0, + "content": "342", + "type": "text" + }, + { + "bbox": [ + 104, + 668, + 507, + 684 + ], + "score": 1.0, + "content": "X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 85, + 678, + 508, + 695 + ], + "spans": [ + { + "bbox": [ + 85, + 681, + 100, + 693 + ], + "score": 1.0, + "content": "343", + "type": "text" + }, + { + "bbox": [ + 114, + 678, + 508, + 695 + ], + "score": 1.0, + "content": "In Proceedings of the thirteenth international conference on artificial intelligence and statistics,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 85, + 689, + 398, + 705 + ], + "spans": [ + { + "bbox": [ + 85, + 693, + 100, + 704 + ], + "score": 1.0, + "content": "344", + "type": "text" + }, + { + "bbox": [ + 113, + 689, + 398, + 705 + ], + "score": 1.0, + "content": "pages 249–256. JMLR Workshop and Conference Proceedings, 2010.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 86, + 711, + 465, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 711, + 465, + 724 + ], + "score": 1.0, + "content": "345 R. E. Goldschmidt. Applications of division by convergence. Master’s thesis, MIT, 1964.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 92, + 72, + 164, + 84 + ], + "lines": [ + { + "bbox": [ + 92, + 72, + 164, + 84 + ], + "spans": [], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "index", + "bbox": [ + 86, + 75, + 508, + 728 + ], + "lines": [ + { + "bbox": [ + 90, + 71, + 165, + 86 + ], + "spans": [ + { + "bbox": [ + 90, + 71, + 165, + 86 + ], + "score": 1.0, + "content": "00 References", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 91, + 506, + 104 + ], + "spans": [ + { + "bbox": [ + 84, + 91, + 101, + 104 + ], + "score": 1.0, + "content": "301", + "type": "text" + }, + { + "bbox": [ + 104, + 91, + 506, + 104 + ], + "score": 1.0, + "content": "N. Agrawal, A. S. Shamsabadi, M. J. Kusner, and A. Gascón. QUOTIENT: Two-party secure neural", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 101, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 84, + 103, + 101, + 115 + ], + "score": 1.0, + "content": "302", + "type": "text" + }, + { + "bbox": [ + 114, + 101, + 506, + 115 + ], + "score": 1.0, + "content": "network training and prediction. In L. Cavallaro, J. Kinder, X. Wang, and J. Katz, editors, ACM", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 113, + 466, + 126 + ], + "spans": [ + { + "bbox": [ + 85, + 114, + 100, + 126 + ], + "score": 1.0, + "content": "303", + "type": "text" + }, + { + "bbox": [ + 115, + 113, + 466, + 126 + ], + "score": 1.0, + "content": "CCS 2019, pages 1231–1247. ACM Press, Nov. 2019. doi: 10.1145/3319535.3339819.", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 132, + 507, + 148 + ], + "spans": [ + { + "bbox": [ + 85, + 135, + 101, + 146 + ], + "score": 1.0, + "content": "304", + "type": "text" + }, + { + "bbox": [ + 104, + 132, + 507, + 148 + ], + "score": 1.0, + "content": "M. Aliasgari, M. Blanton, Y. Zhang, and A. Steele. Secure computation on floating point numbers.", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 144, + 309, + 157 + ], + "spans": [ + { + "bbox": [ + 85, + 146, + 100, + 157 + ], + "score": 1.0, + "content": "305", + "type": "text" + }, + { + "bbox": [ + 114, + 144, + 309, + 157 + ], + "score": 1.0, + "content": "In NDSS 2013. The Internet Society, Feb. 2013.", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 162, + 507, + 180 + ], + "spans": [ + { + "bbox": [ + 85, + 166, + 101, + 177 + ], + "score": 1.0, + "content": "306", + "type": "text" + }, + { + "bbox": [ + 102, + 162, + 507, + 180 + ], + "score": 1.0, + "content": "A. Aly and N. P. Smart. Benchmarking privacy preserving scientific operations. In R. H. Deng,", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 174, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 85, + 177, + 100, + 188 + ], + "score": 1.0, + "content": "307", + "type": "text" + }, + { + "bbox": [ + 114, + 174, + 506, + 190 + ], + "score": 1.0, + "content": "V. Gauthier-Umaña, M. Ochoa, and M. Yung, editors, ACNS 19, volume 11464 of LNCS, pages", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 185, + 446, + 201 + ], + "spans": [ + { + "bbox": [ + 85, + 187, + 100, + 199 + ], + "score": 1.0, + "content": "308", + "type": "text" + }, + { + "bbox": [ + 115, + 185, + 446, + 201 + ], + "score": 1.0, + "content": "509–529. Springer, Heidelberg, June 2019. doi: 10.1007/978-3-030-21568-2_25.", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 205, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 85, + 208, + 101, + 218 + ], + "score": 1.0, + "content": "309", + "type": "text" + }, + { + "bbox": [ + 104, + 205, + 506, + 220 + ], + "score": 1.0, + "content": "T. Araki, J. Furukawa, Y. Lindell, A. Nof, and K. Ohara. High-throughput semi-honest secure", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 216, + 507, + 232 + ], + "spans": [ + { + "bbox": [ + 85, + 218, + 100, + 230 + ], + "score": 1.0, + "content": "310", + "type": "text" + }, + { + "bbox": [ + 114, + 216, + 507, + 232 + ], + "score": 1.0, + "content": "three-party computation with an honest majority. In E. R. Weippl, S. Katzenbeisser, C. Kruegel,", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 227, + 507, + 242 + ], + "spans": [ + { + "bbox": [ + 85, + 230, + 100, + 241 + ], + "score": 1.0, + "content": "311", + "type": "text" + }, + { + "bbox": [ + 113, + 227, + 507, + 242 + ], + "score": 1.0, + "content": "A. C. Myers, and S. Halevi, editors, ACM CCS 2016, pages 805–817. ACM Press, Oct. 2016. doi:", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 238, + 229, + 252 + ], + "spans": [ + { + "bbox": [ + 85, + 240, + 100, + 252 + ], + "score": 1.0, + "content": "312", + "type": "text" + }, + { + "bbox": [ + 115, + 238, + 229, + 252 + ], + "score": 1.0, + "content": "10.1145/2976749.2978331.", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 255, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 84, + 260, + 101, + 273 + ], + "score": 1.0, + "content": "313", + "type": "text" + }, + { + "bbox": [ + 102, + 255, + 506, + 275 + ], + "score": 1.0, + "content": "T. Araki, A. Barak, J. Furukawa, M. Keller, Y. Lindell, K. Ohara, and H. Tsuchida. Generalizing", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 268, + 507, + 285 + ], + "spans": [ + { + "bbox": [ + 84, + 271, + 101, + 284 + ], + "score": 1.0, + "content": "314", + "type": "text" + }, + { + "bbox": [ + 114, + 268, + 507, + 285 + ], + "score": 1.0, + "content": "the SPDZ compiler for other protocols. In D. Lie, M. Mannan, M. Backes, and X. Wang, editors,", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 280, + 478, + 295 + ], + "spans": [ + { + "bbox": [ + 85, + 283, + 100, + 294 + ], + "score": 1.0, + "content": "315", + "type": "text" + }, + { + "bbox": [ + 112, + 280, + 478, + 295 + ], + "score": 1.0, + "content": "ACM CCS 2018, pages 880–895. ACM Press, Oct. 2018. doi: 10.1145/3243734.3243854.", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 300, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 85, + 303, + 101, + 314 + ], + "score": 1.0, + "content": "316", + "type": "text" + }, + { + "bbox": [ + 104, + 300, + 506, + 316 + ], + "score": 1.0, + "content": "M. Barni, C. Orlandi, and A. Piva. A privacy-preserving protocol for neural-network-based computa-", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 312, + 487, + 326 + ], + "spans": [ + { + "bbox": [ + 85, + 314, + 100, + 325 + ], + "score": 1.0, + "content": "317", + "type": "text" + }, + { + "bbox": [ + 115, + 312, + 487, + 326 + ], + "score": 1.0, + "content": "tion. In Proceedings of the 8th workshop on Multimedia and security, pages 146–151, 2006.", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 85, + 334, + 101, + 344 + ], + "score": 1.0, + "content": "318", + "type": "text" + }, + { + "bbox": [ + 103, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "J. C. Benaloh and J. Leichter. Generalized secret sharing and monotone functions. In S. Goldwasser,", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 85, + 344, + 100, + 356 + ], + "score": 1.0, + "content": "319", + "type": "text" + }, + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "editor, CRYPTO’88, volume 403 of LNCS, pages 27–35. Springer, Heidelberg, Aug. 1990. doi:", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 354, + 227, + 367 + ], + "spans": [ + { + "bbox": [ + 85, + 355, + 100, + 367 + ], + "score": 1.0, + "content": "320", + "type": "text" + }, + { + "bbox": [ + 114, + 354, + 227, + 367 + ], + "score": 1.0, + "content": "10.1007/0-387-34799-2_3.", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 374, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 85, + 376, + 101, + 387 + ], + "score": 1.0, + "content": "321", + "type": "text" + }, + { + "bbox": [ + 105, + 374, + 506, + 388 + ], + "score": 1.0, + "content": "O. Catrina and A. Saxena. Secure computation with fixed-point numbers. In R. Sion, editor, FC", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 385, + 422, + 399 + ], + "spans": [ + { + "bbox": [ + 85, + 387, + 100, + 398 + ], + "score": 1.0, + "content": "322", + "type": "text" + }, + { + "bbox": [ + 115, + 385, + 422, + 399 + ], + "score": 1.0, + "content": "2010, volume 6052 of LNCS, pages 35–50. Springer, Heidelberg, Jan. 2010.", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 406, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 84, + 406, + 101, + 419 + ], + "score": 1.0, + "content": "323", + "type": "text" + }, + { + "bbox": [ + 105, + 406, + 506, + 419 + ], + "score": 1.0, + "content": "M. Dahl, J. Mancuso, Y. Dupis, B. Decoste, M. Giraud, I. Livingstone, J. Patriquin, and G. Uhma.", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 416, + 508, + 432 + ], + "spans": [ + { + "bbox": [ + 85, + 418, + 100, + 429 + ], + "score": 1.0, + "content": "324", + "type": "text" + }, + { + "bbox": [ + 114, + 416, + 508, + 432 + ], + "score": 1.0, + "content": "Private machine learning in tensorflow using secure computation. CoRR, abs/1810.08130, 2018.", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 428, + 307, + 442 + ], + "spans": [ + { + "bbox": [ + 85, + 429, + 100, + 441 + ], + "score": 1.0, + "content": "325", + "type": "text" + }, + { + "bbox": [ + 116, + 428, + 307, + 442 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1810.08130.", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 447, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 85, + 450, + 101, + 460 + ], + "score": 1.0, + "content": "326", + "type": "text" + }, + { + "bbox": [ + 104, + 447, + 506, + 462 + ], + "score": 1.0, + "content": "A. Dalskov, D. Escudero, and M. Keller. Fantastic four: Honest-majority four-party secure com-", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 457, + 507, + 474 + ], + "spans": [ + { + "bbox": [ + 85, + 460, + 100, + 471 + ], + "score": 1.0, + "content": "327", + "type": "text" + }, + { + "bbox": [ + 114, + 457, + 507, + 474 + ], + "score": 1.0, + "content": "putation with malicious security. In 30th USENIX Security Symposium (USENIX Security 21),", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 468, + 142, + 483 + ], + "spans": [ + { + "bbox": [ + 85, + 471, + 100, + 482 + ], + "score": 1.0, + "content": "328", + "type": "text" + }, + { + "bbox": [ + 114, + 468, + 142, + 483 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 489, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 84, + 490, + 101, + 503 + ], + "score": 1.0, + "content": "329", + "type": "text" + }, + { + "bbox": [ + 104, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "A. P. K. Dalskov, D. Escudero, and M. Keller. Secure evaluation of quantized neural networks.", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 499, + 406, + 515 + ], + "spans": [ + { + "bbox": [ + 85, + 502, + 100, + 513 + ], + "score": 1.0, + "content": "330", + "type": "text" + }, + { + "bbox": [ + 114, + 499, + 406, + 515 + ], + "score": 1.0, + "content": "PoPETs, 2020(4):355–375, Oct. 2020. doi: 10.2478/popets-2020-0077.", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 520, + 506, + 536 + ], + "spans": [ + { + "bbox": [ + 85, + 523, + 101, + 533 + ], + "score": 1.0, + "content": "331", + "type": "text" + }, + { + "bbox": [ + 104, + 520, + 506, + 536 + ], + "score": 1.0, + "content": "I. Damgård, M. Fitzi, E. Kiltz, J. B. Nielsen, and T. Toft. Unconditionally secure constant-rounds", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 531, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 85, + 533, + 100, + 545 + ], + "score": 1.0, + "content": "332", + "type": "text" + }, + { + "bbox": [ + 114, + 531, + 506, + 547 + ], + "score": 1.0, + "content": "multi-party computation for equality, comparison, bits and exponentiation. In S. Halevi and", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 542, + 507, + 558 + ], + "spans": [ + { + "bbox": [ + 85, + 544, + 100, + 556 + ], + "score": 1.0, + "content": "333", + "type": "text" + }, + { + "bbox": [ + 114, + 542, + 507, + 558 + ], + "score": 1.0, + "content": "T. Rabin, editors, TCC 2006, volume 3876 of LNCS, pages 285–304. Springer, Heidelberg, Mar.", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 554, + 258, + 567 + ], + "spans": [ + { + "bbox": [ + 85, + 555, + 100, + 567 + ], + "score": 1.0, + "content": "334", + "type": "text" + }, + { + "bbox": [ + 115, + 554, + 258, + 567 + ], + "score": 1.0, + "content": "2006. doi: 10.1007/11681878_15.", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 85, + 575, + 101, + 586 + ], + "score": 1.0, + "content": "335", + "type": "text" + }, + { + "bbox": [ + 104, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "I. Damgård, D. Escudero, T. K. Frederiksen, M. Keller, P. Scholl, and N. Volgushev. New primitives", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 585, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 85, + 586, + 100, + 598 + ], + "score": 1.0, + "content": "336", + "type": "text" + }, + { + "bbox": [ + 115, + 585, + 505, + 599 + ], + "score": 1.0, + "content": "for actively-secure MPC over rings with applications to private machine learning. In 2019 IEEE", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 595, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 85, + 597, + 100, + 609 + ], + "score": 1.0, + "content": "337", + "type": "text" + }, + { + "bbox": [ + 114, + 595, + 506, + 611 + ], + "score": 1.0, + "content": "Symposium on Security and Privacy, pages 1102–1120. IEEE Computer Society Press, May 2019.", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 606, + 235, + 619 + ], + "spans": [ + { + "bbox": [ + 85, + 608, + 100, + 619 + ], + "score": 1.0, + "content": "338", + "type": "text" + }, + { + "bbox": [ + 115, + 606, + 235, + 619 + ], + "score": 1.0, + "content": "doi: 10.1109/SP.2019.00078.", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 625, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 84, + 627, + 101, + 640 + ], + "score": 1.0, + "content": "339", + "type": "text" + }, + { + "bbox": [ + 104, + 625, + 506, + 641 + ], + "score": 1.0, + "content": "H. Eerikson, M. Keller, C. Orlandi, P. Pullonen, J. Puura, and M. Simkin. Use your brain! Arithmetic", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 637, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 84, + 639, + 101, + 652 + ], + "score": 1.0, + "content": "340", + "type": "text" + }, + { + "bbox": [ + 114, + 637, + 506, + 653 + ], + "score": 1.0, + "content": "3PC for any modulus with active security. In Y. T. Kalai, A. D. Smith, and D. Wichs, editors, ITC", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 648, + 461, + 663 + ], + "spans": [ + { + "bbox": [ + 85, + 650, + 100, + 661 + ], + "score": 1.0, + "content": "341", + "type": "text" + }, + { + "bbox": [ + 114, + 648, + 461, + 663 + ], + "score": 1.0, + "content": "2020, pages 5:1–5:24. Schloss Dagstuhl, June 2020. doi: 10.4230/LIPIcs.ITC.2020.5.", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 668, + 507, + 684 + ], + "spans": [ + { + "bbox": [ + 85, + 671, + 101, + 681 + ], + "score": 1.0, + "content": "342", + "type": "text" + }, + { + "bbox": [ + 104, + 668, + 507, + 684 + ], + "score": 1.0, + "content": "X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks.", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 678, + 508, + 695 + ], + "spans": [ + { + "bbox": [ + 85, + 681, + 100, + 693 + ], + "score": 1.0, + "content": "343", + "type": "text" + }, + { + "bbox": [ + 114, + 678, + 508, + 695 + ], + "score": 1.0, + "content": "In Proceedings of the thirteenth international conference on artificial intelligence and statistics,", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 85, + 689, + 398, + 705 + ], + "spans": [ + { + "bbox": [ + 85, + 693, + 100, + 704 + ], + "score": 1.0, + "content": "344", + "type": "text" + }, + { + "bbox": [ + 113, + 689, + 398, + 705 + ], + "score": 1.0, + "content": "pages 249–256. JMLR Workshop and Conference Proceedings, 2010.", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 711, + 465, + 724 + ], + "spans": [ + { + "bbox": [ + 86, + 711, + 465, + 724 + ], + "score": 1.0, + "content": "345 R. E. Goldschmidt. Applications of division by convergence. Master’s thesis, MIT, 1964.", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 101, + 86 + ], + "score": 1.0, + "content": "346", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 102, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "D. Gunning, A. Hannun, M. Ibrahim, B. Knott, L. van der Maaten, V. Reis, S. Sengupta, S. Venkatara-", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 84, + 86, + 101, + 97 + ], + "score": 1.0, + "content": "347", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "man, and X. Zhou. Crypten: A new research tool for secure machine learning with pytorch,", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 93, + 144, + 108 + ], + "spans": [ + { + "bbox": [ + 84, + 96, + 101, + 107 + ], + "score": 1.0, + "content": "348", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 114, + 93, + 144, + 108 + ], + "score": 1.0, + "content": "2019.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 82, + 113, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 82, + 113, + 506, + 129 + ], + "score": 1.0, + "content": "349 I. Hubara, M. Courbariaux, D. Soudry, R. El-Yaniv, and Y. Bengio. Binarized neural networks. In", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 124, + 501, + 138 + ], + "spans": [ + { + "bbox": [ + 86, + 127, + 101, + 138 + ], + "score": 1.0, + "content": "350", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 113, + 124, + 501, + 138 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 146, + 506, + 158 + ], + "spans": [ + { + "bbox": [ + 84, + 147, + 101, + 158 + ], + "score": 1.0, + "content": "351", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 146, + 506, + 158 + ], + "score": 1.0, + "content": "M. Keller. MP-SPDZ: A versatile framework for multi-party computation. In J. Ligatti, X. Ou,", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 157, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 84, + 158, + 101, + 169 + ], + "score": 1.0, + "content": "352", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 114, + 157, + 506, + 169 + ], + "score": 1.0, + "content": "J. Katz, and G. Vigna, editors, ACM CCS 20, pages 1575–1590. ACM Press, Nov. 2020. doi:", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 166, + 228, + 180 + ], + "spans": [ + { + "bbox": [ + 84, + 169, + 101, + 180 + ], + "score": 1.0, + "content": "353", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 166, + 228, + 180 + ], + "score": 1.0, + "content": "10.1145/3372297.3417872.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 188, + 435, + 200 + ], + "spans": [ + { + "bbox": [ + 86, + 189, + 101, + 200 + ], + "score": 1.0, + "content": "354", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 188, + 435, + 200 + ], + "score": 1.0, + "content": "M. Keller and K. Sun. Effectiveness of MPC-friendly softmax replacement, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 206, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 84, + 206, + 506, + 221 + ], + "score": 1.0, + "content": "355 V. Kolesnikov, A.-R. Sadeghi, and T. Schneider. A systematic approach to practically efficient general", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 218, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 84, + 220, + 101, + 231 + ], + "score": 1.0, + "content": "356", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 218, + 505, + 232 + ], + "score": 1.0, + "content": "two-party secure function evaluation protocols and their modular design. Journal of Computer", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 229, + 243, + 243 + ], + "spans": [ + { + "bbox": [ + 84, + 230, + 100, + 242 + ], + "score": 1.0, + "content": "357", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 114, + 229, + 243, + 243 + ], + "score": 1.0, + "content": "Security, 21(2):283–315, 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 248, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 86, + 250, + 101, + 262 + ], + "score": 1.0, + "content": "358", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 248, + 506, + 262 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 260, + 376, + 273 + ], + "spans": [ + { + "bbox": [ + 84, + 262, + 101, + 273 + ], + "score": 1.0, + "content": "359", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 113, + 260, + 376, + 273 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 280, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 84, + 281, + 101, + 292 + ], + "score": 1.0, + "content": "360", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 280, + 506, + 292 + ], + "score": 1.0, + "content": "Y. LeCun, C. Cortes, and C. Burges. Mnist handwritten digit database. ATT Labs [Online]. Avail-", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 84, + 292, + 101, + 303 + ], + "score": 1.0, + "content": "361", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "able: http: // yann. lecun. com/ exdb/ mnist , 2, 2010. Creative Commons Attribution-Share", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 301, + 440, + 315 + ], + "spans": [ + { + "bbox": [ + 84, + 303, + 101, + 315 + ], + "score": 1.0, + "content": "362", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 301, + 440, + 315 + ], + "score": 1.0, + "content": "Alike 3.0 license, https://creativecommons.org/licenses/by-sa/3.0/.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 322, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 86, + 322, + 505, + 334 + ], + "score": 1.0, + "content": "363 J. Liu, M. Juuti, Y. Lu, and N. Asokan. Oblivious neural network predictions via MiniONN", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 84, + 334, + 101, + 345 + ], + "score": 1.0, + "content": "364", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "transformations. In B. M. Thuraisingham, D. Evans, T. Malkin, and D. Xu, editors, ACM CCS", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 343, + 460, + 357 + ], + "spans": [ + { + "bbox": [ + 84, + 345, + 101, + 356 + ], + "score": 1.0, + "content": "365", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 343, + 460, + 357 + ], + "score": 1.0, + "content": "2017, pages 619–631. ACM Press, Oct. / Nov. 2017. doi: 10.1145/3133956.3134056.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 363, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 84, + 365, + 101, + 376 + ], + "score": 1.0, + "content": "366", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 105, + 363, + 506, + 378 + ], + "score": 1.0, + "content": "W.-j. Lu, Y. Fang, Z. Huang, C. Hong, C. Chen, H. Qu, Y. Zhou, and K. Ren. Faster secure multiparty", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 374, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 84, + 375, + 101, + 387 + ], + "score": 1.0, + "content": "367", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 374, + 506, + 389 + ], + "score": 1.0, + "content": "computation of adaptive gradient descent. In Proceedings of the 2020 Workshop on Privacy-", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 84, + 386, + 101, + 398 + ], + "score": 1.0, + "content": "368", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "Preserving Machine Learning in Practice, PPMLP’20, page 47–49, New York, NY, USA, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 395, + 507, + 410 + ], + "spans": [ + { + "bbox": [ + 84, + 397, + 99, + 409 + ], + "score": 1.0, + "content": "369", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 395, + 507, + 410 + ], + "score": 1.0, + "content": "Association for Computing Machinery. ISBN 9781450380881. doi: 10.1145/3411501.3419427.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 407, + 347, + 421 + ], + "spans": [ + { + "bbox": [ + 84, + 409, + 101, + 421 + ], + "score": 1.0, + "content": "370", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 117, + 407, + 347, + 419 + ], + "score": 1.0, + "content": "URL https://doi.org/10.1145/3411501.3419427.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 86, + 424, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 86, + 428, + 101, + 439 + ], + "score": 1.0, + "content": "371", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 424, + 506, + 442 + ], + "score": 1.0, + "content": "P. Mohassel and P. Rindal. ABY3: A mixed protocol framework for machine learning. In D. Lie,", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 438, + 507, + 452 + ], + "spans": [ + { + "bbox": [ + 84, + 439, + 101, + 451 + ], + "score": 1.0, + "content": "372", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 438, + 507, + 452 + ], + "score": 1.0, + "content": "M. Mannan, M. Backes, and X. Wang, editors, ACM CCS 2018, pages 35–52. ACM Press, Oct.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 450, + 275, + 462 + ], + "spans": [ + { + "bbox": [ + 84, + 451, + 101, + 462 + ], + "score": 1.0, + "content": "373", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 450, + 275, + 462 + ], + "score": 1.0, + "content": "2018. doi: 10.1145/3243734.3243760.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 466, + 507, + 484 + ], + "spans": [ + { + "bbox": [ + 84, + 466, + 507, + 484 + ], + "score": 1.0, + "content": "374 P. Mohassel and Y. Zhang. SecureML: A system for scalable privacy-preserving machine learning.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 84, + 481, + 101, + 493 + ], + "score": 1.0, + "content": "375", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "In 2017 IEEE Symposium on Security and Privacy, pages 19–38. IEEE Computer Society Press,", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 492, + 267, + 504 + ], + "spans": [ + { + "bbox": [ + 84, + 492, + 101, + 504 + ], + "score": 1.0, + "content": "376", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 492, + 267, + 504 + ], + "score": 1.0, + "content": "May 2017. doi: 10.1109/SP.2017.12.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 84, + 513, + 101, + 524 + ], + "score": 1.0, + "content": "377", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 106, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "V. Nair and G. E. Hinton. Rectified linear units improve Restricted Boltzmann machines. In Pro-", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 520, + 507, + 537 + ], + "spans": [ + { + "bbox": [ + 84, + 523, + 101, + 535 + ], + "score": 1.0, + "content": "378", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 113, + 520, + 507, + 537 + ], + "score": 1.0, + "content": "ceedings of the 27th International Conference on International Conference on Machine Learning,", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 531, + 250, + 546 + ], + "spans": [ + { + "bbox": [ + 84, + 534, + 101, + 545 + ], + "score": 1.0, + "content": "379", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 531, + 250, + 546 + ], + "score": 1.0, + "content": "ICML’10, pages 807–814, 2010.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 552, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 84, + 552, + 506, + 566 + ], + "score": 1.0, + "content": "380 D. L. Quoc, F. Gregor, S. Arnautov, R. Kunkel, P. Bhatotia, and C. Fetzer. securetf: A secure", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 564, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 84, + 565, + 100, + 577 + ], + "score": 1.0, + "content": "381", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "tensorflow framework. CoRR, abs/2101.08204, 2021. URL https://arxiv.org/abs/2101.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 574, + 149, + 587 + ], + "spans": [ + { + "bbox": [ + 84, + 576, + 101, + 587 + ], + "score": 1.0, + "content": "382", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 574, + 149, + 587 + ], + "score": 1.0, + "content": "08204.", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 593, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 84, + 596, + 101, + 607 + ], + "score": 1.0, + "content": "383", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 103, + 593, + 506, + 608 + ], + "score": 1.0, + "content": "M. S. Riazi, C. Weinert, O. Tkachenko, E. M. Songhori, T. Schneider, and F. Koushanfar. Chameleon:", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 605, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 84, + 606, + 101, + 618 + ], + "score": 1.0, + "content": "384", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 605, + 506, + 619 + ], + "score": 1.0, + "content": "A hybrid secure computation framework for machine learning applications. In J. Kim, G.-J. Ahn,", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 614, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 84, + 617, + 101, + 629 + ], + "score": 1.0, + "content": "385", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 113, + 614, + 506, + 631 + ], + "score": 1.0, + "content": "S. Kim, Y. Kim, J. López, and T. Kim, editors, ASIACCS 18, pages 707–721. ACM Press, Apr.", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 626, + 144, + 641 + ], + "spans": [ + { + "bbox": [ + 84, + 629, + 101, + 640 + ], + "score": 1.0, + "content": "386", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 626, + 144, + 641 + ], + "score": 1.0, + "content": "2018.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 645, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 84, + 648, + 101, + 659 + ], + "score": 1.0, + "content": "387", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 103, + 645, + 506, + 660 + ], + "score": 1.0, + "content": "D. Rotaru and T. Wood. MArBled circuits: Mixing arithmetic and Boolean circuits with active", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 657, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 84, + 659, + 101, + 671 + ], + "score": 1.0, + "content": "388", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 116, + 657, + 506, + 672 + ], + "score": 1.0, + "content": "security. In F. Hao, S. Ruj, and S. Sen Gupta, editors, INDOCRYPT 2019, volume 11898 of LNCS,", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 668, + 470, + 683 + ], + "spans": [ + { + "bbox": [ + 84, + 671, + 101, + 682 + ], + "score": 1.0, + "content": "389", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 113, + 668, + 470, + 683 + ], + "score": 1.0, + "content": "pages 227–249. Springer, Heidelberg, Dec. 2019. doi: 10.1007/978-3-030-35423-7_12.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 84, + 690, + 101, + 702 + ], + "score": 1.0, + "content": "390", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 104, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "T. Ryffel, A. Trask, M. Dahl, B. Wagner, J. Mancuso, D. Rueckert, and J. Passerat-Palmbach. A", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 84, + 702, + 100, + 713 + ], + "score": 1.0, + "content": "391", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "generic framework for privacy preserving deep learning. CoRR, abs/1811.04017, 2018. URL", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 84, + 711, + 286, + 725 + ], + "spans": [ + { + "bbox": [ + 84, + 713, + 101, + 724 + ], + "score": 1.0, + "content": "392", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 115, + 711, + 286, + 725 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1811.04017.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_start_line": true + } + ], + "index": 23.5, + "bbox_fs": [ + 84, + 71, + 508, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 84, + 47, + 508, + 727 + ], + "lines": [ + { + "bbox": [ + 86, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 86, + 74, + 101, + 86 + ], + "score": 1.0, + "content": "346", + "type": "text" + }, + { + "bbox": [ + 102, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "D. Gunning, A. Hannun, M. Ibrahim, B. Knott, L. van der Maaten, V. Reis, S. Sengupta, S. Venkatara-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 84, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 84, + 86, + 101, + 97 + ], + "score": 1.0, + "content": "347", + "type": "text" + }, + { + "bbox": [ + 115, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "man, and X. Zhou. Crypten: A new research tool for secure machine learning with pytorch,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 84, + 93, + 144, + 108 + ], + "spans": [ + { + "bbox": [ + 84, + 96, + 101, + 107 + ], + "score": 1.0, + "content": "348", + "type": "text" + }, + { + "bbox": [ + 114, + 93, + 144, + 108 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 82, + 113, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 82, + 113, + 506, + 129 + ], + "score": 1.0, + "content": "349 I. Hubara, M. Courbariaux, D. Soudry, R. El-Yaniv, and Y. Bengio. Binarized neural networks. In", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 86, + 124, + 501, + 138 + ], + "spans": [ + { + "bbox": [ + 86, + 127, + 101, + 138 + ], + "score": 1.0, + "content": "350", + "type": "text" + }, + { + "bbox": [ + 113, + 124, + 501, + 138 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 84, + 146, + 506, + 158 + ], + "spans": [ + { + "bbox": [ + 84, + 147, + 101, + 158 + ], + "score": 1.0, + "content": "351", + "type": "text" + }, + { + "bbox": [ + 105, + 146, + 506, + 158 + ], + "score": 1.0, + "content": "M. Keller. MP-SPDZ: A versatile framework for multi-party computation. In J. Ligatti, X. Ou,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 84, + 157, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 84, + 158, + 101, + 169 + ], + "score": 1.0, + "content": "352", + "type": "text" + }, + { + "bbox": [ + 114, + 157, + 506, + 169 + ], + "score": 1.0, + "content": "J. Katz, and G. Vigna, editors, ACM CCS 20, pages 1575–1590. ACM Press, Nov. 2020. doi:", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 84, + 166, + 228, + 180 + ], + "spans": [ + { + "bbox": [ + 84, + 169, + 101, + 180 + ], + "score": 1.0, + "content": "353", + "type": "text" + }, + { + "bbox": [ + 115, + 166, + 228, + 180 + ], + "score": 1.0, + "content": "10.1145/3372297.3417872.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 86, + 188, + 435, + 200 + ], + "spans": [ + { + "bbox": [ + 86, + 189, + 101, + 200 + ], + "score": 1.0, + "content": "354", + "type": "text" + }, + { + "bbox": [ + 104, + 188, + 435, + 200 + ], + "score": 1.0, + "content": "M. Keller and K. Sun. Effectiveness of MPC-friendly softmax replacement, 2020.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 84, + 206, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 84, + 206, + 506, + 221 + ], + "score": 1.0, + "content": "355 V. Kolesnikov, A.-R. Sadeghi, and T. Schneider. A systematic approach to practically efficient general", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 84, + 218, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 84, + 220, + 101, + 231 + ], + "score": 1.0, + "content": "356", + "type": "text" + }, + { + "bbox": [ + 115, + 218, + 505, + 232 + ], + "score": 1.0, + "content": "two-party secure function evaluation protocols and their modular design. Journal of Computer", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 84, + 229, + 243, + 243 + ], + "spans": [ + { + "bbox": [ + 84, + 230, + 100, + 242 + ], + "score": 1.0, + "content": "357", + "type": "text" + }, + { + "bbox": [ + 114, + 229, + 243, + 243 + ], + "score": 1.0, + "content": "Security, 21(2):283–315, 2013.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 86, + 248, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 86, + 250, + 101, + 262 + ], + "score": 1.0, + "content": "358", + "type": "text" + }, + { + "bbox": [ + 105, + 248, + 506, + 262 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 84, + 260, + 376, + 273 + ], + "spans": [ + { + "bbox": [ + 84, + 262, + 101, + 273 + ], + "score": 1.0, + "content": "359", + "type": "text" + }, + { + "bbox": [ + 113, + 260, + 376, + 273 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 84, + 280, + 506, + 292 + ], + "spans": [ + { + "bbox": [ + 84, + 281, + 101, + 292 + ], + "score": 1.0, + "content": "360", + "type": "text" + }, + { + "bbox": [ + 106, + 280, + 506, + 292 + ], + "score": 1.0, + "content": "Y. LeCun, C. Cortes, and C. Burges. Mnist handwritten digit database. ATT Labs [Online]. Avail-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 84, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 84, + 292, + 101, + 303 + ], + "score": 1.0, + "content": "361", + "type": "text" + }, + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "able: http: // yann. lecun. com/ exdb/ mnist , 2, 2010. Creative Commons Attribution-Share", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 84, + 301, + 440, + 315 + ], + "spans": [ + { + "bbox": [ + 84, + 303, + 101, + 315 + ], + "score": 1.0, + "content": "362", + "type": "text" + }, + { + "bbox": [ + 115, + 301, + 440, + 315 + ], + "score": 1.0, + "content": "Alike 3.0 license, https://creativecommons.org/licenses/by-sa/3.0/.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 86, + 322, + 505, + 334 + ], + "spans": [ + { + "bbox": [ + 86, + 322, + 505, + 334 + ], + "score": 1.0, + "content": "363 J. Liu, M. Juuti, Y. Lu, and N. Asokan. Oblivious neural network predictions via MiniONN", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 84, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 84, + 334, + 101, + 345 + ], + "score": 1.0, + "content": "364", + "type": "text" + }, + { + "bbox": [ + 116, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "transformations. In B. M. Thuraisingham, D. Evans, T. Malkin, and D. Xu, editors, ACM CCS", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 84, + 343, + 460, + 357 + ], + "spans": [ + { + "bbox": [ + 84, + 345, + 101, + 356 + ], + "score": 1.0, + "content": "365", + "type": "text" + }, + { + "bbox": [ + 115, + 343, + 460, + 357 + ], + "score": 1.0, + "content": "2017, pages 619–631. ACM Press, Oct. / Nov. 2017. doi: 10.1145/3133956.3134056.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 84, + 363, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 84, + 365, + 101, + 376 + ], + "score": 1.0, + "content": "366", + "type": "text" + }, + { + "bbox": [ + 105, + 363, + 506, + 378 + ], + "score": 1.0, + "content": "W.-j. Lu, Y. Fang, Z. Huang, C. Hong, C. Chen, H. Qu, Y. Zhou, and K. Ren. Faster secure multiparty", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 84, + 374, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 84, + 375, + 101, + 387 + ], + "score": 1.0, + "content": "367", + "type": "text" + }, + { + "bbox": [ + 115, + 374, + 506, + 389 + ], + "score": 1.0, + "content": "computation of adaptive gradient descent. In Proceedings of the 2020 Workshop on Privacy-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 84, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 84, + 386, + 101, + 398 + ], + "score": 1.0, + "content": "368", + "type": "text" + }, + { + "bbox": [ + 115, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "Preserving Machine Learning in Practice, PPMLP’20, page 47–49, New York, NY, USA, 2020.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 84, + 395, + 507, + 410 + ], + "spans": [ + { + "bbox": [ + 84, + 397, + 99, + 409 + ], + "score": 1.0, + "content": "369", + "type": "text" + }, + { + "bbox": [ + 115, + 395, + 507, + 410 + ], + "score": 1.0, + "content": "Association for Computing Machinery. ISBN 9781450380881. doi: 10.1145/3411501.3419427.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 84, + 407, + 347, + 421 + ], + "spans": [ + { + "bbox": [ + 84, + 409, + 101, + 421 + ], + "score": 1.0, + "content": "370", + "type": "text" + }, + { + "bbox": [ + 117, + 407, + 347, + 419 + ], + "score": 1.0, + "content": "URL https://doi.org/10.1145/3411501.3419427.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 86, + 424, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 86, + 428, + 101, + 439 + ], + "score": 1.0, + "content": "371", + "type": "text" + }, + { + "bbox": [ + 104, + 424, + 506, + 442 + ], + "score": 1.0, + "content": "P. Mohassel and P. Rindal. ABY3: A mixed protocol framework for machine learning. In D. Lie,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 84, + 438, + 507, + 452 + ], + "spans": [ + { + "bbox": [ + 84, + 439, + 101, + 451 + ], + "score": 1.0, + "content": "372", + "type": "text" + }, + { + "bbox": [ + 115, + 438, + 507, + 452 + ], + "score": 1.0, + "content": "M. Mannan, M. Backes, and X. Wang, editors, ACM CCS 2018, pages 35–52. ACM Press, Oct.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 84, + 450, + 275, + 462 + ], + "spans": [ + { + "bbox": [ + 84, + 451, + 101, + 462 + ], + "score": 1.0, + "content": "373", + "type": "text" + }, + { + "bbox": [ + 116, + 450, + 275, + 462 + ], + "score": 1.0, + "content": "2018. doi: 10.1145/3243734.3243760.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 84, + 466, + 507, + 484 + ], + "spans": [ + { + "bbox": [ + 84, + 466, + 507, + 484 + ], + "score": 1.0, + "content": "374 P. Mohassel and Y. Zhang. SecureML: A system for scalable privacy-preserving machine learning.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 84, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 84, + 481, + 101, + 493 + ], + "score": 1.0, + "content": "375", + "type": "text" + }, + { + "bbox": [ + 115, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "In 2017 IEEE Symposium on Security and Privacy, pages 19–38. IEEE Computer Society Press,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 84, + 492, + 267, + 504 + ], + "spans": [ + { + "bbox": [ + 84, + 492, + 101, + 504 + ], + "score": 1.0, + "content": "376", + "type": "text" + }, + { + "bbox": [ + 116, + 492, + 267, + 504 + ], + "score": 1.0, + "content": "May 2017. doi: 10.1109/SP.2017.12.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 84, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 84, + 513, + 101, + 524 + ], + "score": 1.0, + "content": "377", + "type": "text" + }, + { + "bbox": [ + 106, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "V. Nair and G. E. Hinton. Rectified linear units improve Restricted Boltzmann machines. In Pro-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 84, + 520, + 507, + 537 + ], + "spans": [ + { + "bbox": [ + 84, + 523, + 101, + 535 + ], + "score": 1.0, + "content": "378", + "type": "text" + }, + { + "bbox": [ + 113, + 520, + 507, + 537 + ], + "score": 1.0, + "content": "ceedings of the 27th International Conference on International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 84, + 531, + 250, + 546 + ], + "spans": [ + { + "bbox": [ + 84, + 534, + 101, + 545 + ], + "score": 1.0, + "content": "379", + "type": "text" + }, + { + "bbox": [ + 115, + 531, + 250, + 546 + ], + "score": 1.0, + "content": "ICML’10, pages 807–814, 2010.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 84, + 552, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 84, + 552, + 506, + 566 + ], + "score": 1.0, + "content": "380 D. L. Quoc, F. Gregor, S. Arnautov, R. Kunkel, P. Bhatotia, and C. Fetzer. securetf: A secure", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 84, + 564, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 84, + 565, + 100, + 577 + ], + "score": 1.0, + "content": "381", + "type": "text" + }, + { + "bbox": [ + 116, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "tensorflow framework. CoRR, abs/2101.08204, 2021. URL https://arxiv.org/abs/2101.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 84, + 574, + 149, + 587 + ], + "spans": [ + { + "bbox": [ + 84, + 576, + 101, + 587 + ], + "score": 1.0, + "content": "382", + "type": "text" + }, + { + "bbox": [ + 116, + 574, + 149, + 587 + ], + "score": 1.0, + "content": "08204.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 84, + 593, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 84, + 596, + 101, + 607 + ], + "score": 1.0, + "content": "383", + "type": "text" + }, + { + "bbox": [ + 103, + 593, + 506, + 608 + ], + "score": 1.0, + "content": "M. S. Riazi, C. Weinert, O. Tkachenko, E. M. Songhori, T. Schneider, and F. Koushanfar. Chameleon:", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 84, + 605, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 84, + 606, + 101, + 618 + ], + "score": 1.0, + "content": "384", + "type": "text" + }, + { + "bbox": [ + 115, + 605, + 506, + 619 + ], + "score": 1.0, + "content": "A hybrid secure computation framework for machine learning applications. In J. Kim, G.-J. Ahn,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 84, + 614, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 84, + 617, + 101, + 629 + ], + "score": 1.0, + "content": "385", + "type": "text" + }, + { + "bbox": [ + 113, + 614, + 506, + 631 + ], + "score": 1.0, + "content": "S. Kim, Y. Kim, J. López, and T. Kim, editors, ASIACCS 18, pages 707–721. ACM Press, Apr.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 84, + 626, + 144, + 641 + ], + "spans": [ + { + "bbox": [ + 84, + 629, + 101, + 640 + ], + "score": 1.0, + "content": "386", + "type": "text" + }, + { + "bbox": [ + 115, + 626, + 144, + 641 + ], + "score": 1.0, + "content": "2018.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 84, + 645, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 84, + 648, + 101, + 659 + ], + "score": 1.0, + "content": "387", + "type": "text" + }, + { + "bbox": [ + 103, + 645, + 506, + 660 + ], + "score": 1.0, + "content": "D. Rotaru and T. Wood. MArBled circuits: Mixing arithmetic and Boolean circuits with active", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 84, + 657, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 84, + 659, + 101, + 671 + ], + "score": 1.0, + "content": "388", + "type": "text" + }, + { + "bbox": [ + 116, + 657, + 506, + 672 + ], + "score": 1.0, + "content": "security. In F. Hao, S. Ruj, and S. Sen Gupta, editors, INDOCRYPT 2019, volume 11898 of LNCS,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 84, + 668, + 470, + 683 + ], + "spans": [ + { + "bbox": [ + 84, + 671, + 101, + 682 + ], + "score": 1.0, + "content": "389", + "type": "text" + }, + { + "bbox": [ + 113, + 668, + 470, + 683 + ], + "score": 1.0, + "content": "pages 227–249. Springer, Heidelberg, Dec. 2019. doi: 10.1007/978-3-030-35423-7_12.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 84, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 84, + 690, + 101, + 702 + ], + "score": 1.0, + "content": "390", + "type": "text" + }, + { + "bbox": [ + 104, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "T. Ryffel, A. Trask, M. Dahl, B. Wagner, J. Mancuso, D. Rueckert, and J. Passerat-Palmbach. A", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 84, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 84, + 702, + 100, + 713 + ], + "score": 1.0, + "content": "391", + "type": "text" + }, + { + "bbox": [ + 115, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "generic framework for privacy preserving deep learning. CoRR, abs/1811.04017, 2018. URL", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 84, + 711, + 286, + 725 + ], + "spans": [ + { + "bbox": [ + 84, + 713, + 101, + 724 + ], + "score": 1.0, + "content": "392", + "type": "text" + }, + { + "bbox": [ + 115, + 711, + 286, + 725 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1811.04017.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 751 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "11", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "index", + "bbox": [ + 84, + 47, + 508, + 727 + ], + "lines": [], + "index": 23, + "bbox_fs": [ + 82, + 72, + 507, + 725 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 95, + 72, + 506, + 166 + ], + "lines": [ + { + "bbox": [ + 96, + 72, + 505, + 87 + ], + "spans": [ + { + "bbox": [ + 96, + 72, + 505, + 87 + ], + "score": 1.0, + "content": "3 S. Tan, B. Knott, Y. Tian, and D. J. Wu. CryptGPU: Fast privacy-preserving machine learning on the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 82, + 167, + 97 + ], + "spans": [ + { + "bbox": [ + 115, + 82, + 167, + 97 + ], + "score": 1.0, + "content": "GPU, 2021.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 103, + 102, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 103, + 102, + 506, + 115 + ], + "score": 1.0, + "content": "S. Wagh, D. Gupta, and N. Chandran. SecureNN: 3-party secure computation for neural network", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 113, + 432, + 127 + ], + "spans": [ + { + "bbox": [ + 115, + 113, + 432, + 127 + ], + "score": 1.0, + "content": "training. PoPETs, 2019(3):26–49, July 2019. doi: 10.2478/popets-2019-0035.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 103, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 103, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "S. Wagh, S. Tople, F. Benhamouda, E. Kushilevitz, P. Mittal, and T. Rabin. Falcon: Honest-majority", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 142, + 508, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 142, + 508, + 158 + ], + "score": 1.0, + "content": "maliciously secure framework for private deep learning. PoPETs, 2021(1):188–208, Jan. 2021.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 250, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 250, + 168 + ], + "score": 1.0, + "content": "doi: 10.2478/popets-2021-0011.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 88, + 186, + 156, + 199 + ], + "lines": [ + { + "bbox": [ + 104, + 185, + 158, + 200 + ], + "spans": [ + { + "bbox": [ + 104, + 185, + 158, + 200 + ], + "score": 1.0, + "content": "Checklist", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 131, + 207, + 208, + 218 + ], + "lines": [ + { + "bbox": [ + 129, + 205, + 210, + 220 + ], + "spans": [ + { + "bbox": [ + 129, + 205, + 210, + 220 + ], + "score": 1.0, + "content": "1. For all authors...", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 146, + 222, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 146, + 222, + 504, + 234 + ], + "spans": [ + { + "bbox": [ + 146, + 222, + 504, + 234 + ], + "score": 1.0, + "content": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 162, + 233, + 288, + 245 + ], + "spans": [ + { + "bbox": [ + 162, + 233, + 288, + 245 + ], + "score": 1.0, + "content": "contributions and scope? [Yes]", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 144, + 245, + 436, + 259 + ], + "spans": [ + { + "bbox": [ + 144, + 245, + 436, + 259 + ], + "score": 1.0, + "content": "(b) Did you describe the limitations of your work? [Yes] See Section 7.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 145, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 145, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "(c) Did you discuss any potential negative societal impacts of your work? [No] We only", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 160, + 269, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 160, + 269, + 506, + 282 + ], + "score": 1.0, + "content": "work with MNIST, and we believe that the potential negative impacts associated to it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 162, + 280, + 217, + 293 + ], + "spans": [ + { + "bbox": [ + 162, + 280, + 217, + 293 + ], + "score": 1.0, + "content": "are very low.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 144, + 292, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 144, + 292, + 505, + 307 + ], + "score": 1.0, + "content": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 162, + 304, + 214, + 317 + ], + "spans": [ + { + "bbox": [ + 162, + 304, + 214, + 317 + ], + "score": 1.0, + "content": "them? [Yes]", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 131, + 319, + 302, + 331 + ], + "lines": [ + { + "bbox": [ + 129, + 318, + 304, + 333 + ], + "spans": [ + { + "bbox": [ + 129, + 318, + 304, + 333 + ], + "score": 1.0, + "content": "2. If you are including theoretical results...", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 146, + 334, + 452, + 359 + ], + "lines": [ + { + "bbox": [ + 145, + 334, + 453, + 347 + ], + "spans": [ + { + "bbox": [ + 145, + 334, + 453, + 347 + ], + "score": 1.0, + "content": "(a) Did you state the full set of assumptions of all theoretical results? [N/A]", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 145, + 347, + 424, + 360 + ], + "spans": [ + { + "bbox": [ + 145, + 347, + 424, + 360 + ], + "score": 1.0, + "content": "(b) Did you include complete proofs of all theoretical results? [N/A]", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 130, + 362, + 241, + 374 + ], + "lines": [ + { + "bbox": [ + 128, + 360, + 243, + 376 + ], + "spans": [ + { + "bbox": [ + 128, + 360, + 243, + 376 + ], + "score": 1.0, + "content": "3. If you ran experiments...", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 146, + 377, + 505, + 482 + ], + "lines": [ + { + "bbox": [ + 145, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 145, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "(a) Did you include the code, data, and instructions needed to reproduce the main experi-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 162, + 388, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 162, + 388, + 505, + 399 + ], + "score": 1.0, + "content": "mental results (either in the supplemental material or as a URL)? [Yes] We include all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 162, + 399, + 495, + 410 + ], + "spans": [ + { + "bbox": [ + 162, + 399, + 495, + 410 + ], + "score": 1.0, + "content": "code in the supplemental material, and the references include the URL for MNIST.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 146, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 146, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 161, + 423, + 305, + 434 + ], + "spans": [ + { + "bbox": [ + 161, + 423, + 305, + 434 + ], + "score": 1.0, + "content": "were chosen)? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 146, + 434, + 507, + 449 + ], + "spans": [ + { + "bbox": [ + 146, + 434, + 507, + 449 + ], + "score": 1.0, + "content": "(c) Did you report error bars (e.g., with respect to the random seed after running experi-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 162, + 446, + 351, + 459 + ], + "spans": [ + { + "bbox": [ + 162, + 446, + 351, + 459 + ], + "score": 1.0, + "content": "ments multiple times)? [Yes] Only in Figure 2.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 146, + 457, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 146, + 457, + 505, + 473 + ], + "score": 1.0, + "content": "(d) Did you include the total amount of compute and the type of resources used (e.g., type", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 162, + 470, + 429, + 482 + ], + "spans": [ + { + "bbox": [ + 162, + 470, + 429, + 482 + ], + "score": 1.0, + "content": "of GPUs, internal cluster, or cloud provider)? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 132, + 485, + 504, + 497 + ], + "lines": [ + { + "bbox": [ + 129, + 483, + 507, + 499 + ], + "spans": [ + { + "bbox": [ + 129, + 483, + 507, + 499 + ], + "score": 1.0, + "content": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 146, + 500, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 145, + 499, + 483, + 512 + ], + "spans": [ + { + "bbox": [ + 145, + 499, + 483, + 512 + ], + "score": 1.0, + "content": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 145, + 513, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 145, + 513, + 506, + 525 + ], + "score": 1.0, + "content": "(b) Did you mention the license of the assets? [Yes] See the references and and Section 5.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 146, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 146, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 162, + 537, + 355, + 549 + ], + "spans": [ + { + "bbox": [ + 162, + 537, + 355, + 549 + ], + "score": 1.0, + "content": "Our code is included the supplemental material.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 146, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 146, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "(d) Did you discuss whether and how consent was obtained from people whose data you’re", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 162, + 561, + 254, + 573 + ], + "spans": [ + { + "bbox": [ + 162, + 561, + 254, + 573 + ], + "score": 1.0, + "content": "using/curating? [N/A]", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 146, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 146, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "(e) Did you discuss whether the data you are using/curating contains personally identifiable", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 162, + 584, + 325, + 596 + ], + "spans": [ + { + "bbox": [ + 162, + 584, + 325, + 596 + ], + "score": 1.0, + "content": "information or offensive content? [N/A]", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 131, + 599, + 432, + 611 + ], + "lines": [ + { + "bbox": [ + 128, + 597, + 433, + 613 + ], + "spans": [ + { + "bbox": [ + 128, + 597, + 433, + 613 + ], + "score": 1.0, + "content": "5. If you used crowdsourcing or conducted research with human subjects...", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 146, + 614, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 145, + 613, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 145, + 613, + 506, + 627 + ], + "score": 1.0, + "content": "(a) Did you include the full text of instructions given to participants and screenshots, if", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 162, + 625, + 237, + 637 + ], + "spans": [ + { + "bbox": [ + 162, + 625, + 237, + 637 + ], + "score": 1.0, + "content": "applicable? [N/A]", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 145, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 145, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "(b) Did you describe any potential participant risks, with links to Institutional Review", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 161, + 649, + 342, + 662 + ], + "spans": [ + { + "bbox": [ + 161, + 649, + 342, + 662 + ], + "score": 1.0, + "content": "Board (IRB) approvals, if applicable? [N/A]", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 147, + 661, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 147, + 661, + 505, + 674 + ], + "score": 1.0, + "content": "(c) Did you include the estimated hourly wage paid to participants and the total amount", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 162, + 673, + 333, + 685 + ], + "spans": [ + { + "bbox": [ + 162, + 673, + 333, + 685 + ], + "score": 1.0, + "content": "spent on participant compensation? [N/A]", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 85, + 73, + 102, + 699 + ], + "lines": [ + { + "bbox": [ + 85, + 74, + 100, + 85 + ], + "spans": [ + { + "bbox": [ + 85, + 74, + 100, + 85 + ], + "score": 1.0, + "content": "39", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 85, + 102, + 98 + ], + "spans": [ + { + "bbox": [ + 84, + 85, + 102, + 98 + ], + "score": 1.0, + "content": "394", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 104, + 100, + 115 + ], + "spans": [ + { + "bbox": [ + 84, + 104, + 100, + 115 + ], + "score": 1.0, + "content": "395", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 115, + 101, + 130 + ], + "spans": [ + { + "bbox": [ + 84, + 115, + 101, + 130 + ], + "score": 1.0, + "content": "396", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 133, + 100, + 145 + ], + "spans": [ + { + "bbox": [ + 84, + 133, + 100, + 145 + ], + "score": 1.0, + "content": "397", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 145, + 100, + 156 + ], + "spans": [ + { + "bbox": [ + 84, + 145, + 100, + 156 + ], + "score": 1.0, + "content": "398", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 155, + 101, + 168 + ], + "spans": [ + { + "bbox": [ + 84, + 155, + 101, + 168 + ], + "score": 1.0, + "content": "399", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 190, + 100, + 201 + ], + "spans": [ + { + "bbox": [ + 84, + 190, + 100, + 201 + ], + "score": 1.0, + "content": "400", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 208, + 101, + 222 + ], + "spans": [ + { + "bbox": [ + 84, + 208, + 101, + 222 + ], + "score": 1.0, + "content": "401", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 224, + 100, + 235 + ], + "spans": [ + { + "bbox": [ + 84, + 224, + 100, + 235 + ], + "score": 1.0, + "content": "402", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 235, + 100, + 246 + ], + "spans": [ + { + "bbox": [ + 84, + 235, + 100, + 246 + ], + "score": 1.0, + "content": "403", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 247, + 101, + 260 + ], + "spans": [ + { + "bbox": [ + 84, + 247, + 101, + 260 + ], + "score": 1.0, + "content": "404", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 259, + 102, + 272 + ], + "spans": [ + { + "bbox": [ + 84, + 259, + 102, + 272 + ], + "score": 1.0, + "content": "405", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 271, + 102, + 284 + ], + "spans": [ + { + "bbox": [ + 84, + 271, + 102, + 284 + ], + "score": 1.0, + "content": "406", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 282, + 100, + 294 + ], + "spans": [ + { + "bbox": [ + 85, + 282, + 100, + 294 + ], + "score": 1.0, + "content": "407", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 295, + 101, + 306 + ], + "spans": [ + { + "bbox": [ + 84, + 295, + 101, + 306 + ], + "score": 1.0, + "content": "408", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 306, + 101, + 319 + ], + "spans": [ + { + "bbox": [ + 84, + 306, + 101, + 319 + ], + "score": 1.0, + "content": "409", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 320, + 101, + 335 + ], + "spans": [ + { + "bbox": [ + 84, + 320, + 101, + 335 + ], + "score": 1.0, + "content": "410", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 336, + 100, + 347 + ], + "spans": [ + { + "bbox": [ + 84, + 336, + 100, + 347 + ], + "score": 1.0, + "content": "411", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 349, + 102, + 361 + ], + "spans": [ + { + "bbox": [ + 84, + 349, + 102, + 361 + ], + "score": 1.0, + "content": "412", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 363, + 101, + 378 + ], + "spans": [ + { + "bbox": [ + 84, + 363, + 101, + 378 + ], + "score": 1.0, + "content": "413", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 379, + 101, + 390 + ], + "spans": [ + { + "bbox": [ + 84, + 379, + 101, + 390 + ], + "score": 1.0, + "content": "414", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 390, + 101, + 401 + ], + "spans": [ + { + "bbox": [ + 84, + 390, + 101, + 401 + ], + "score": 1.0, + "content": "415", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 401, + 102, + 413 + ], + "spans": [ + { + "bbox": [ + 84, + 401, + 102, + 413 + ], + "score": 1.0, + "content": "416", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 413, + 100, + 425 + ], + "spans": [ + { + "bbox": [ + 84, + 413, + 100, + 425 + ], + "score": 1.0, + "content": "417", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 425, + 101, + 435 + ], + "spans": [ + { + "bbox": [ + 84, + 425, + 101, + 435 + ], + "score": 1.0, + "content": "418", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 438, + 101, + 448 + ], + "spans": [ + { + "bbox": [ + 84, + 438, + 101, + 448 + ], + "score": 1.0, + "content": "419", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 448, + 100, + 460 + ], + "spans": [ + { + "bbox": [ + 84, + 448, + 100, + 460 + ], + "score": 1.0, + "content": "420", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 461, + 100, + 472 + ], + "spans": [ + { + "bbox": [ + 84, + 461, + 100, + 472 + ], + "score": 1.0, + "content": "421", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 471, + 101, + 486 + ], + "spans": [ + { + "bbox": [ + 84, + 471, + 101, + 486 + ], + "score": 1.0, + "content": "422", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 486, + 101, + 500 + ], + "spans": [ + { + "bbox": [ + 84, + 486, + 101, + 500 + ], + "score": 1.0, + "content": "423", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 501, + 101, + 514 + ], + "spans": [ + { + "bbox": [ + 84, + 501, + 101, + 514 + ], + "score": 1.0, + "content": "424", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 514, + 101, + 527 + ], + "spans": [ + { + "bbox": [ + 84, + 514, + 101, + 527 + ], + "score": 1.0, + "content": "425", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 527, + 102, + 540 + ], + "spans": [ + { + "bbox": [ + 84, + 527, + 102, + 540 + ], + "score": 1.0, + "content": "426", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 537, + 101, + 551 + ], + "spans": [ + { + "bbox": [ + 84, + 537, + 101, + 551 + ], + "score": 1.0, + "content": "427", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 551, + 102, + 564 + ], + "spans": [ + { + "bbox": [ + 84, + 551, + 102, + 564 + ], + "score": 1.0, + "content": "428", + "type": "text" + } + ] + }, + { + "bbox": [ + 85, + 562, + 101, + 575 + ], + "spans": [ + { + "bbox": [ + 85, + 562, + 101, + 575 + ], + "score": 1.0, + "content": "429", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 575, + 100, + 586 + ], + "spans": [ + { + "bbox": [ + 84, + 575, + 100, + 586 + ], + "score": 1.0, + "content": "430", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 586, + 100, + 599 + ], + "spans": [ + { + "bbox": [ + 84, + 586, + 100, + 599 + ], + "score": 1.0, + "content": "431", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 600, + 101, + 614 + ], + "spans": [ + { + "bbox": [ + 84, + 600, + 101, + 614 + ], + "score": 1.0, + "content": "432", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 615, + 100, + 627 + ], + "spans": [ + { + "bbox": [ + 84, + 615, + 100, + 627 + ], + "score": 1.0, + "content": "433", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 626, + 102, + 640 + ], + "spans": [ + { + "bbox": [ + 84, + 626, + 102, + 640 + ], + "score": 1.0, + "content": "434", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 639, + 100, + 651 + ], + "spans": [ + { + "bbox": [ + 84, + 639, + 100, + 651 + ], + "score": 1.0, + "content": "435", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 650, + 102, + 663 + ], + "spans": [ + { + "bbox": [ + 84, + 650, + 102, + 663 + ], + "score": 1.0, + "content": "436", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 663, + 100, + 675 + ], + "spans": [ + { + "bbox": [ + 84, + 663, + 100, + 675 + ], + "score": 1.0, + "content": "437", + "type": "text" + } + ] + }, + { + "bbox": [ + 84, + 674, + 100, + 686 + ], + "spans": [ + { + "bbox": [ + 84, + 674, + 100, + 686 + ], + "score": 1.0, + "content": "438", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 95, + 72, + 506, + 166 + ], + "lines": [ + { + "bbox": [ + 96, + 72, + 505, + 87 + ], + "spans": [ + { + "bbox": [ + 96, + 72, + 505, + 87 + ], + "score": 1.0, + "content": "3 S. Tan, B. Knott, Y. Tian, and D. J. Wu. CryptGPU: Fast privacy-preserving machine learning on the", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 82, + 167, + 97 + ], + "spans": [ + { + "bbox": [ + 115, + 82, + 167, + 97 + ], + "score": 1.0, + "content": "GPU, 2021.", + "type": "text" + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 102, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 103, + 102, + 506, + 115 + ], + "score": 1.0, + "content": "S. Wagh, D. Gupta, and N. Chandran. SecureNN: 3-party secure computation for neural network", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 113, + 432, + 127 + ], + "spans": [ + { + "bbox": [ + 115, + 113, + 432, + 127 + ], + "score": 1.0, + "content": "training. PoPETs, 2019(3):26–49, July 2019. doi: 10.2478/popets-2019-0035.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 103, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "S. Wagh, S. Tople, F. Benhamouda, E. Kushilevitz, P. Mittal, and T. Rabin. Falcon: Honest-majority", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 142, + 508, + 158 + ], + "spans": [ + { + "bbox": [ + 115, + 142, + 508, + 158 + ], + "score": 1.0, + "content": "maliciously secure framework for private deep learning. PoPETs, 2021(1):188–208, Jan. 2021.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 250, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 250, + 168 + ], + "score": 1.0, + "content": "doi: 10.2478/popets-2021-0011.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + } + ], + "index": 3, + "bbox_fs": [ + 96, + 72, + 508, + 168 + ] + }, + { + "type": "title", + "bbox": [ + 88, + 186, + 156, + 199 + ], + "lines": [ + { + "bbox": [ + 104, + 185, + 158, + 200 + ], + "spans": [ + { + "bbox": [ + 104, + 185, + 158, + 200 + ], + "score": 1.0, + "content": "Checklist", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 131, + 207, + 208, + 218 + ], + "lines": [ + { + "bbox": [ + 129, + 205, + 210, + 220 + ], + "spans": [ + { + "bbox": [ + 129, + 205, + 210, + 220 + ], + "score": 1.0, + "content": "1. For all authors...", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 129, + 205, + 210, + 220 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 222, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 146, + 222, + 504, + 234 + ], + "spans": [ + { + "bbox": [ + 146, + 222, + 504, + 234 + ], + "score": 1.0, + "content": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 233, + 288, + 245 + ], + "spans": [ + { + "bbox": [ + 162, + 233, + 288, + 245 + ], + "score": 1.0, + "content": "contributions and scope? [Yes]", + "type": "text" + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 144, + 245, + 436, + 259 + ], + "spans": [ + { + "bbox": [ + 144, + 245, + 436, + 259 + ], + "score": 1.0, + "content": "(b) Did you describe the limitations of your work? [Yes] See Section 7.", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 145, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "(c) Did you discuss any potential negative societal impacts of your work? [No] We only", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 160, + 269, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 160, + 269, + 506, + 282 + ], + "score": 1.0, + "content": "work with MNIST, and we believe that the potential negative impacts associated to it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 162, + 280, + 217, + 293 + ], + "spans": [ + { + "bbox": [ + 162, + 280, + 217, + 293 + ], + "score": 1.0, + "content": "are very low.", + "type": "text" + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 144, + 292, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 144, + 292, + 505, + 307 + ], + "score": 1.0, + "content": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 304, + 214, + 317 + ], + "spans": [ + { + "bbox": [ + 162, + 304, + 214, + 317 + ], + "score": 1.0, + "content": "them? [Yes]", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + } + ], + "index": 12.5, + "bbox_fs": [ + 144, + 222, + 506, + 317 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 319, + 302, + 331 + ], + "lines": [ + { + "bbox": [ + 129, + 318, + 304, + 333 + ], + "spans": [ + { + "bbox": [ + 129, + 318, + 304, + 333 + ], + "score": 1.0, + "content": "2. If you are including theoretical results...", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17, + "bbox_fs": [ + 129, + 318, + 304, + 333 + ] + }, + { + "type": "text", + "bbox": [ + 146, + 334, + 452, + 359 + ], + "lines": [ + { + "bbox": [ + 145, + 334, + 453, + 347 + ], + "spans": [ + { + "bbox": [ + 145, + 334, + 453, + 347 + ], + "score": 1.0, + "content": "(a) Did you state the full set of assumptions of all theoretical results? [N/A]", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 145, + 347, + 424, + 360 + ], + "spans": [ + { + "bbox": [ + 145, + 347, + 424, + 360 + ], + "score": 1.0, + "content": "(b) Did you include complete proofs of all theoretical results? [N/A]", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 145, + 334, + 453, + 360 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 362, + 241, + 374 + ], + "lines": [ + { + "bbox": [ + 128, + 360, + 243, + 376 + ], + "spans": [ + { + "bbox": [ + 128, + 360, + 243, + 376 + ], + "score": 1.0, + "content": "3. If you ran experiments...", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20, + "bbox_fs": [ + 128, + 360, + 243, + 376 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 377, + 505, + 482 + ], + "lines": [ + { + "bbox": [ + 145, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 145, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "(a) Did you include the code, data, and instructions needed to reproduce the main experi-", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 388, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 162, + 388, + 505, + 399 + ], + "score": 1.0, + "content": "mental results (either in the supplemental material or as a URL)? [Yes] We include all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 162, + 399, + 495, + 410 + ], + "spans": [ + { + "bbox": [ + 162, + 399, + 495, + 410 + ], + "score": 1.0, + "content": "code in the supplemental material, and the references include the URL for MNIST.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 146, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 146, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 423, + 305, + 434 + ], + "spans": [ + { + "bbox": [ + 161, + 423, + 305, + 434 + ], + "score": 1.0, + "content": "were chosen)? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 434, + 507, + 449 + ], + "spans": [ + { + "bbox": [ + 146, + 434, + 507, + 449 + ], + "score": 1.0, + "content": "(c) Did you report error bars (e.g., with respect to the random seed after running experi-", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 446, + 351, + 459 + ], + "spans": [ + { + "bbox": [ + 162, + 446, + 351, + 459 + ], + "score": 1.0, + "content": "ments multiple times)? [Yes] Only in Figure 2.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 457, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 146, + 457, + 505, + 473 + ], + "score": 1.0, + "content": "(d) Did you include the total amount of compute and the type of resources used (e.g., type", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 470, + 429, + 482 + ], + "spans": [ + { + "bbox": [ + 162, + 470, + 429, + 482 + ], + "score": 1.0, + "content": "of GPUs, internal cluster, or cloud provider)? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 29, + "is_list_end_line": true + } + ], + "index": 25, + "bbox_fs": [ + 145, + 376, + 507, + 482 + ] + }, + { + "type": "text", + "bbox": [ + 132, + 485, + 504, + 497 + ], + "lines": [ + { + "bbox": [ + 129, + 483, + 507, + 499 + ], + "spans": [ + { + "bbox": [ + 129, + 483, + 507, + 499 + ], + "score": 1.0, + "content": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30, + "bbox_fs": [ + 129, + 483, + 507, + 499 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 500, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 145, + 499, + 483, + 512 + ], + "spans": [ + { + "bbox": [ + 145, + 499, + 483, + 512 + ], + "score": 1.0, + "content": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Section 6.", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 513, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 145, + 513, + 506, + 525 + ], + "score": 1.0, + "content": "(b) Did you mention the license of the assets? [Yes] See the references and and Section 5.", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 146, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 146, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 537, + 355, + 549 + ], + "spans": [ + { + "bbox": [ + 162, + 537, + 355, + 549 + ], + "score": 1.0, + "content": "Our code is included the supplemental material.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 146, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "(d) Did you discuss whether and how consent was obtained from people whose data you’re", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 561, + 254, + 573 + ], + "spans": [ + { + "bbox": [ + 162, + 561, + 254, + 573 + ], + "score": 1.0, + "content": "using/curating? [N/A]", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 573, + 505, + 586 + ], + "spans": [ + { + "bbox": [ + 146, + 573, + 505, + 586 + ], + "score": 1.0, + "content": "(e) Did you discuss whether the data you are using/curating contains personally identifiable", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 584, + 325, + 596 + ], + "spans": [ + { + "bbox": [ + 162, + 584, + 325, + 596 + ], + "score": 1.0, + "content": "information or offensive content? [N/A]", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + } + ], + "index": 34.5, + "bbox_fs": [ + 145, + 499, + 506, + 596 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 599, + 432, + 611 + ], + "lines": [ + { + "bbox": [ + 128, + 597, + 433, + 613 + ], + "spans": [ + { + "bbox": [ + 128, + 597, + 433, + 613 + ], + "score": 1.0, + "content": "5. If you used crowdsourcing or conducted research with human subjects...", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39, + "bbox_fs": [ + 128, + 597, + 433, + 613 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 614, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 145, + 613, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 145, + 613, + 506, + 627 + ], + "score": 1.0, + "content": "(a) Did you include the full text of instructions given to participants and screenshots, if", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 625, + 237, + 637 + ], + "spans": [ + { + "bbox": [ + 162, + 625, + 237, + 637 + ], + "score": 1.0, + "content": "applicable? [N/A]", + "type": "text" + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 145, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "(b) Did you describe any potential participant risks, with links to Institutional Review", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 649, + 342, + 662 + ], + "spans": [ + { + "bbox": [ + 161, + 649, + 342, + 662 + ], + "score": 1.0, + "content": "Board (IRB) approvals, if applicable? [N/A]", + "type": "text" + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 147, + 661, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 147, + 661, + 505, + 674 + ], + "score": 1.0, + "content": "(c) Did you include the estimated hourly wage paid to participants and the total amount", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 673, + 333, + 685 + ], + "spans": [ + { + "bbox": [ + 162, + 673, + 333, + 685 + ], + "score": 1.0, + "content": "spent on participant compensation? [N/A]", + "type": "text" + } + ], + "index": 45, + "is_list_end_line": true + } + ], + "index": 42.5, + "bbox_fs": [ + 145, + 613, + 506, + 685 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file