diff --git "a/parse/dev/UmvSlP-PyV/UmvSlP-PyV_middle.json" "b/parse/dev/UmvSlP-PyV/UmvSlP-PyV_middle.json" new file mode 100644--- /dev/null +++ "b/parse/dev/UmvSlP-PyV/UmvSlP-PyV_middle.json" @@ -0,0 +1,38616 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 146, + 122, + 466, + 162 + ], + "lines": [ + { + "bbox": [ + 202, + 121, + 412, + 143 + ], + "spans": [ + { + "bbox": [ + 202, + 121, + 412, + 143 + ], + "score": 1.0, + "content": "Beyond neural scaling laws:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 145, + 140, + 466, + 165 + ], + "spans": [ + { + "bbox": [ + 145, + 140, + 466, + 165 + ], + "score": 1.0, + "content": "beating power law scaling via data pruning", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 147, + 203, + 212, + 215 + ], + "lines": [ + { + "bbox": [ + 145, + 203, + 213, + 215 + ], + "spans": [ + { + "bbox": [ + 145, + 203, + 213, + 215 + ], + "score": 1.0, + "content": "Ben Sorscher∗1", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 257, + 203, + 333, + 215 + ], + "lines": [ + { + "bbox": [ + 256, + 203, + 335, + 216 + ], + "spans": [ + { + "bbox": [ + 256, + 203, + 335, + 216 + ], + "score": 1.0, + "content": "Robert Geirhos∗2", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 378, + 203, + 464, + 215 + ], + "lines": [ + { + "bbox": [ + 377, + 202, + 464, + 216 + ], + "spans": [ + { + "bbox": [ + 377, + 202, + 464, + 216 + ], + "score": 1.0, + "content": "Shashank Shekhar3", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 189, + 231, + 265, + 244 + ], + "lines": [ + { + "bbox": [ + 187, + 231, + 266, + 244 + ], + "spans": [ + { + "bbox": [ + 187, + 231, + 266, + 244 + ], + "score": 1.0, + "content": "Surya Ganguli1,3§", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 353, + 231, + 421, + 243 + ], + "lines": [ + { + "bbox": [ + 352, + 231, + 422, + 244 + ], + "spans": [ + { + "bbox": [ + 352, + 231, + 422, + 244 + ], + "score": 1.0, + "content": "Ari S. Morcos3§", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 209, + 272, + 401, + 329 + ], + "lines": [ + { + "bbox": [ + 269, + 270, + 343, + 285 + ], + "spans": [ + { + "bbox": [ + 269, + 270, + 343, + 285 + ], + "score": 1.0, + "content": "∗equal contribution", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 209, + 282, + 402, + 295 + ], + "spans": [ + { + "bbox": [ + 209, + 282, + 402, + 295 + ], + "score": 1.0, + "content": "1Department of Applied Physics, Stanford University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 259, + 293, + 352, + 308 + ], + "spans": [ + { + "bbox": [ + 259, + 293, + 352, + 308 + ], + "score": 1.0, + "content": "2University of Tübingen", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 272, + 304, + 338, + 319 + ], + "spans": [ + { + "bbox": [ + 272, + 304, + 338, + 319 + ], + "score": 1.0, + "content": "3Meta AI (FAIR)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 267, + 316, + 344, + 330 + ], + "spans": [ + { + "bbox": [ + 267, + 316, + 344, + 330 + ], + "score": 1.0, + "content": "§Joint senior authors", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + }, + { + "type": "title", + "bbox": [ + 283, + 357, + 328, + 370 + ], + "lines": [ + { + "bbox": [ + 282, + 357, + 330, + 371 + ], + "spans": [ + { + "bbox": [ + 282, + 357, + 330, + 371 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 143, + 383, + 469, + 590 + ], + "lines": [ + { + "bbox": [ + 142, + 383, + 469, + 396 + ], + "spans": [ + { + "bbox": [ + 142, + 383, + 469, + 396 + ], + "score": 1.0, + "content": "Widely observed neural scaling laws, in which error falls off as a power of the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 394, + 470, + 407 + ], + "spans": [ + { + "bbox": [ + 141, + 394, + 470, + 407 + ], + "score": 1.0, + "content": "training set size, model size, or both, have driven substantial performance im-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 405, + 470, + 417 + ], + "spans": [ + { + "bbox": [ + 141, + 405, + 470, + 417 + ], + "score": 1.0, + "content": "provements in deep learning. However, these improvements through scaling alone", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 416, + 470, + 428 + ], + "spans": [ + { + "bbox": [ + 141, + 416, + 470, + 428 + ], + "score": 1.0, + "content": "require considerable costs in compute and energy. Here we focus on the scaling of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 427, + 469, + 438 + ], + "spans": [ + { + "bbox": [ + 141, + 427, + 469, + 438 + ], + "score": 1.0, + "content": "error with dataset size and show how in theory we can break beyond power law", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 142, + 438, + 469, + 450 + ], + "spans": [ + { + "bbox": [ + 142, + 438, + 469, + 450 + ], + "score": 1.0, + "content": "scaling and potentially even reduce it to exponential scaling instead if we have", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 449, + 469, + 461 + ], + "spans": [ + { + "bbox": [ + 141, + 449, + 469, + 461 + ], + "score": 1.0, + "content": "access to a high-quality data pruning metric that ranks the order in which training", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 142, + 460, + 470, + 471 + ], + "spans": [ + { + "bbox": [ + 142, + 460, + 470, + 471 + ], + "score": 1.0, + "content": "examples should be discarded to achieve any pruned dataset size. We then test", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 470, + 470, + 482 + ], + "spans": [ + { + "bbox": [ + 141, + 470, + 470, + 482 + ], + "score": 1.0, + "content": "this improved scaling prediction with pruned dataset size empirically, and indeed", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 482, + 470, + 493 + ], + "spans": [ + { + "bbox": [ + 141, + 482, + 470, + 493 + ], + "score": 1.0, + "content": "observe better than power law scaling in practice on ResNets trained on CIFAR-10,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 491, + 470, + 506 + ], + "spans": [ + { + "bbox": [ + 141, + 491, + 470, + 506 + ], + "score": 1.0, + "content": "SVHN, and ImageNet. Next, given the importance of finding high-quality pruning", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 503, + 469, + 515 + ], + "spans": [ + { + "bbox": [ + 141, + 503, + 469, + 515 + ], + "score": 1.0, + "content": "metrics, we perform the first large-scale benchmarking study of ten different data", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 514, + 470, + 527 + ], + "spans": [ + { + "bbox": [ + 141, + 514, + 470, + 527 + ], + "score": 1.0, + "content": "pruning metrics on ImageNet. We find most existing high performing metrics", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 525, + 469, + 538 + ], + "spans": [ + { + "bbox": [ + 141, + 525, + 469, + 538 + ], + "score": 1.0, + "content": "scale poorly to ImageNet, while the best are computationally intensive and require", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 536, + 469, + 549 + ], + "spans": [ + { + "bbox": [ + 141, + 536, + 469, + 549 + ], + "score": 1.0, + "content": "labels for every image. We therefore developed a new simple, cheap and scalable", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 547, + 469, + 560 + ], + "spans": [ + { + "bbox": [ + 141, + 547, + 469, + 560 + ], + "score": 1.0, + "content": "self-supervised pruning metric that demonstrates comparable performance to the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 558, + 469, + 570 + ], + "spans": [ + { + "bbox": [ + 141, + 558, + 469, + 570 + ], + "score": 1.0, + "content": "best supervised metrics. Overall, our work suggests that the discovery of good", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 569, + 469, + 581 + ], + "spans": [ + { + "bbox": [ + 142, + 569, + 469, + 581 + ], + "score": 1.0, + "content": "data-pruning metrics may provide a viable path forward to substantially improved", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 140, + 578, + 467, + 594 + ], + "spans": [ + { + "bbox": [ + 140, + 578, + 467, + 594 + ], + "score": 1.0, + "content": "neural scaling laws, thereby reducing the resource costs of modern deep learning.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 107, + 612, + 190, + 626 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 192, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 192, + 628 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 507, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 651 + ], + "score": 1.0, + "content": "Empirically observed neural scaling laws [1, 2, 3, 4, 5, 6, 7, 8] in many domains of machine learning,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "including vision, language, and speech, demonstrate that test error often falls off as a power law with", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "either the amount of training data, model size, or compute. Such power law scaling has motivated", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "significant societal investments in data collection, compute, and associated energy consumption.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "However, power law scaling is extremely weak and unsustainable. For example, a drop in error", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 702, + 306, + 712 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 306, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 306, + 714 + ], + "score": 1.0, + "content": "∗work done during an internship at Meta AI (FAIR)", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 731, + 385, + 742 + ], + "lines": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "spans": [ + { + "bbox": [ + 106, + 730, + 386, + 743 + ], + "score": 1.0, + "content": "36th Conference on Neural Information Processing Systems (NeurIPS 2022).", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 101, + 503, + 108 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 146, + 122, + 466, + 162 + ], + "lines": [ + { + "bbox": [ + 202, + 121, + 412, + 143 + ], + "spans": [ + { + "bbox": [ + 202, + 121, + 412, + 143 + ], + "score": 1.0, + "content": "Beyond neural scaling laws:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 145, + 140, + 466, + 165 + ], + "spans": [ + { + "bbox": [ + 145, + 140, + 466, + 165 + ], + "score": 1.0, + "content": "beating power law scaling via data pruning", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 147, + 203, + 212, + 215 + ], + "lines": [ + { + "bbox": [ + 145, + 203, + 213, + 215 + ], + "spans": [ + { + "bbox": [ + 145, + 203, + 213, + 215 + ], + "score": 1.0, + "content": "Ben Sorscher∗1", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 257, + 203, + 333, + 215 + ], + "lines": [ + { + "bbox": [ + 256, + 203, + 335, + 216 + ], + "spans": [ + { + "bbox": [ + 256, + 203, + 335, + 216 + ], + "score": 1.0, + "content": "Robert Geirhos∗2", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3, + "bbox_fs": [ + 256, + 203, + 335, + 216 + ] + }, + { + "type": "text", + "bbox": [ + 378, + 203, + 464, + 215 + ], + "lines": [ + { + "bbox": [ + 377, + 202, + 464, + 216 + ], + "spans": [ + { + "bbox": [ + 377, + 202, + 464, + 216 + ], + "score": 1.0, + "content": "Shashank Shekhar3", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 377, + 202, + 464, + 216 + ] + }, + { + "type": "title", + "bbox": [ + 189, + 231, + 265, + 244 + ], + "lines": [ + { + "bbox": [ + 187, + 231, + 266, + 244 + ], + "spans": [ + { + "bbox": [ + 187, + 231, + 266, + 244 + ], + "score": 1.0, + "content": "Surya Ganguli1,3§", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 353, + 231, + 421, + 243 + ], + "lines": [ + { + "bbox": [ + 352, + 231, + 422, + 244 + ], + "spans": [ + { + "bbox": [ + 352, + 231, + 422, + 244 + ], + "score": 1.0, + "content": "Ari S. Morcos3§", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6, + "bbox_fs": [ + 352, + 231, + 422, + 244 + ] + }, + { + "type": "text", + "bbox": [ + 209, + 272, + 401, + 329 + ], + "lines": [ + { + "bbox": [ + 269, + 270, + 343, + 285 + ], + "spans": [ + { + "bbox": [ + 269, + 270, + 343, + 285 + ], + "score": 1.0, + "content": "∗equal contribution", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 209, + 282, + 402, + 295 + ], + "spans": [ + { + "bbox": [ + 209, + 282, + 402, + 295 + ], + "score": 1.0, + "content": "1Department of Applied Physics, Stanford University", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 259, + 293, + 352, + 308 + ], + "spans": [ + { + "bbox": [ + 259, + 293, + 352, + 308 + ], + "score": 1.0, + "content": "2University of Tübingen", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 272, + 304, + 338, + 319 + ], + "spans": [ + { + "bbox": [ + 272, + 304, + 338, + 319 + ], + "score": 1.0, + "content": "3Meta AI (FAIR)", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 267, + 316, + 344, + 330 + ], + "spans": [ + { + "bbox": [ + 267, + 316, + 344, + 330 + ], + "score": 1.0, + "content": "§Joint senior authors", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9, + "bbox_fs": [ + 209, + 270, + 402, + 330 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 357, + 328, + 370 + ], + "lines": [ + { + "bbox": [ + 282, + 357, + 330, + 371 + ], + "spans": [ + { + "bbox": [ + 282, + 357, + 330, + 371 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 143, + 383, + 469, + 590 + ], + "lines": [ + { + "bbox": [ + 142, + 383, + 469, + 396 + ], + "spans": [ + { + "bbox": [ + 142, + 383, + 469, + 396 + ], + "score": 1.0, + "content": "Widely observed neural scaling laws, in which error falls off as a power of the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 394, + 470, + 407 + ], + "spans": [ + { + "bbox": [ + 141, + 394, + 470, + 407 + ], + "score": 1.0, + "content": "training set size, model size, or both, have driven substantial performance im-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 405, + 470, + 417 + ], + "spans": [ + { + "bbox": [ + 141, + 405, + 470, + 417 + ], + "score": 1.0, + "content": "provements in deep learning. However, these improvements through scaling alone", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 416, + 470, + 428 + ], + "spans": [ + { + "bbox": [ + 141, + 416, + 470, + 428 + ], + "score": 1.0, + "content": "require considerable costs in compute and energy. Here we focus on the scaling of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 427, + 469, + 438 + ], + "spans": [ + { + "bbox": [ + 141, + 427, + 469, + 438 + ], + "score": 1.0, + "content": "error with dataset size and show how in theory we can break beyond power law", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 142, + 438, + 469, + 450 + ], + "spans": [ + { + "bbox": [ + 142, + 438, + 469, + 450 + ], + "score": 1.0, + "content": "scaling and potentially even reduce it to exponential scaling instead if we have", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 449, + 469, + 461 + ], + "spans": [ + { + "bbox": [ + 141, + 449, + 469, + 461 + ], + "score": 1.0, + "content": "access to a high-quality data pruning metric that ranks the order in which training", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 142, + 460, + 470, + 471 + ], + "spans": [ + { + "bbox": [ + 142, + 460, + 470, + 471 + ], + "score": 1.0, + "content": "examples should be discarded to achieve any pruned dataset size. We then test", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 470, + 470, + 482 + ], + "spans": [ + { + "bbox": [ + 141, + 470, + 470, + 482 + ], + "score": 1.0, + "content": "this improved scaling prediction with pruned dataset size empirically, and indeed", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 482, + 470, + 493 + ], + "spans": [ + { + "bbox": [ + 141, + 482, + 470, + 493 + ], + "score": 1.0, + "content": "observe better than power law scaling in practice on ResNets trained on CIFAR-10,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 491, + 470, + 506 + ], + "spans": [ + { + "bbox": [ + 141, + 491, + 470, + 506 + ], + "score": 1.0, + "content": "SVHN, and ImageNet. Next, given the importance of finding high-quality pruning", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 503, + 469, + 515 + ], + "spans": [ + { + "bbox": [ + 141, + 503, + 469, + 515 + ], + "score": 1.0, + "content": "metrics, we perform the first large-scale benchmarking study of ten different data", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 514, + 470, + 527 + ], + "spans": [ + { + "bbox": [ + 141, + 514, + 470, + 527 + ], + "score": 1.0, + "content": "pruning metrics on ImageNet. We find most existing high performing metrics", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 525, + 469, + 538 + ], + "spans": [ + { + "bbox": [ + 141, + 525, + 469, + 538 + ], + "score": 1.0, + "content": "scale poorly to ImageNet, while the best are computationally intensive and require", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 536, + 469, + 549 + ], + "spans": [ + { + "bbox": [ + 141, + 536, + 469, + 549 + ], + "score": 1.0, + "content": "labels for every image. We therefore developed a new simple, cheap and scalable", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 547, + 469, + 560 + ], + "spans": [ + { + "bbox": [ + 141, + 547, + 469, + 560 + ], + "score": 1.0, + "content": "self-supervised pruning metric that demonstrates comparable performance to the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 558, + 469, + 570 + ], + "spans": [ + { + "bbox": [ + 141, + 558, + 469, + 570 + ], + "score": 1.0, + "content": "best supervised metrics. Overall, our work suggests that the discovery of good", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 569, + 469, + 581 + ], + "spans": [ + { + "bbox": [ + 142, + 569, + 469, + 581 + ], + "score": 1.0, + "content": "data-pruning metrics may provide a viable path forward to substantially improved", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 140, + 578, + 467, + 594 + ], + "spans": [ + { + "bbox": [ + 140, + 578, + 467, + 594 + ], + "score": 1.0, + "content": "neural scaling laws, thereby reducing the resource costs of modern deep learning.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 22, + "bbox_fs": [ + 140, + 383, + 470, + 594 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 612, + 190, + 626 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 192, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 192, + 628 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 637, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 507, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 651 + ], + "score": 1.0, + "content": "Empirically observed neural scaling laws [1, 2, 3, 4, 5, 6, 7, 8] in many domains of machine learning,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "including vision, language, and speech, demonstrate that test error often falls off as a power law with", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "either the amount of training data, model size, or compute. Such power law scaling has motivated", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 671, + 506, + 684 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 506, + 684 + ], + "score": 1.0, + "content": "significant societal investments in data collection, compute, and associated energy consumption.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "However, power law scaling is extremely weak and unsustainable. For example, a drop in error", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 128, + 415 + ], + "score": 1.0, + "content": "from", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 129, + 402, + 144, + 414 + ], + "score": 0.85, + "content": "3 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 144, + 402, + 155, + 415 + ], + "score": 1.0, + "content": "to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 156, + 402, + 171, + 414 + ], + "score": 0.86, + "content": "2 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 171, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "might require an order of magnitude more data, compute, or energy. In language", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 421, + 426 + ], + "score": 1.0, + "content": "modeling with large transformers, a drop in cross entropy loss from about 3.4 to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 422, + 413, + 457, + 424 + ], + "score": 0.4, + "content": "2 . 8 \\mathrm { n a t s } ^ { 2 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 458, + 414, + 493, + 426 + ], + "score": 1.0, + "content": "requires", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 493, + 414, + 505, + 424 + ], + "score": 0.32, + "content": "I O", + "type": "inline_equation", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "times more training data (Fig. 1 in [2]). Also, for large vision transformers, an additional 2 billion", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "pre-training data points (starting from 1 billion) leads to an accuracy gain on ImageNet of a few", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 447, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 506, + 459 + ], + "score": 1.0, + "content": "percentage points (Fig. 1 in [7]). Here we ask whether we might be able to do better. For example,", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "can we achieve exponential scaling instead, with a good strategy for selecting training examples?", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 357, + 481 + ], + "score": 1.0, + "content": "Such vastly superior scaling would mean that we could go from", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 358, + 468, + 372, + 479 + ], + "score": 0.87, + "content": "3 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 373, + 468, + 383, + 481 + ], + "score": 1.0, + "content": "to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 383, + 468, + 398, + 479 + ], + "score": 0.87, + "content": "2 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 399, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "error by only adding a few", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 479, + 437, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 338, + 491 + ], + "score": 1.0, + "content": "carefully chosen training examples, rather than collecting", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 338, + 479, + 357, + 490 + ], + "score": 0.87, + "content": "1 0 \\times", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 357, + 479, + 437, + 491 + ], + "score": 1.0, + "content": "more random ones.", + "type": "text", + "cross_page": true + } + ], + "index": 21 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 637, + 507, + 694 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 75, + 503, + 250 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 75, + 503, + 250 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 75, + 503, + 250 + ], + "spans": [ + { + "bbox": [ + 110, + 75, + 503, + 250 + ], + "score": 0.976, + "type": "image", + "image_path": "f4951b0b0544dc88c37572ef6cd5e8307cf709eff161b62fe14d4d6cb443efed.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 75, + 503, + 133.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 133.33333333333334, + 503, + 191.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 191.66666666666669, + 503, + 250.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 256, + 505, + 376 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 255, + 506, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 506, + 269 + ], + "score": 1.0, + "content": "Figure 1: Our analytic theory of data pruning predicts that power law scaling of test error with respect", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 266, + 506, + 280 + ], + "spans": [ + { + "bbox": [ + 104, + 266, + 347, + 280 + ], + "score": 1.0, + "content": "to dataset size can be beaten. A: Test error as a function of", + "type": "text" + }, + { + "bbox": [ + 347, + 267, + 405, + 279 + ], + "score": 0.93, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 266, + 426, + 280 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 426, + 267, + 451, + 277 + ], + "score": 0.9, + "content": "\\theta = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 266, + 506, + 280 + ], + "score": 1.0, + "content": ". We observe", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 277, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 506, + 289 + ], + "score": 1.0, + "content": "an excellent match between our analytic theory (solid curves) and numerical simulations (dots) of", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 243, + 301 + ], + "score": 1.0, + "content": "perceptron learning at parameters", + "type": "text" + }, + { + "bbox": [ + 244, + 289, + 274, + 299 + ], + "score": 0.86, + "content": "{ \\bf N } = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 289, + 300, + 301 + ], + "score": 1.0, + "content": "(here:", + "type": "text" + }, + { + "bbox": [ + 301, + 289, + 331, + 299 + ], + "score": 0.85, + "content": "{ \\bf N } = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "constant throughout figure). The red curve", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 297, + 503, + 315 + ], + "spans": [ + { + "bbox": [ + 104, + 297, + 256, + 315 + ], + "score": 1.0, + "content": "indicates the Pareto optimal test error", + "type": "text" + }, + { + "bbox": [ + 257, + 302, + 263, + 309 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 297, + 405, + 315 + ], + "score": 1.0, + "content": "achievable from a tradeoff between", + "type": "text" + }, + { + "bbox": [ + 406, + 301, + 421, + 311 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 297, + 439, + 315 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 439, + 300, + 446, + 311 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 297, + 479, + 315 + ], + "score": 1.0, + "content": "at fixed", + "type": "text" + }, + { + "bbox": [ + 479, + 301, + 503, + 312 + ], + "score": 0.73, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 309, + 506, + 324 + ], + "spans": [ + { + "bbox": [ + 104, + 309, + 413, + 324 + ], + "score": 1.0, + "content": "B: We find that when data is abundant (scarce) corresponding to large (small)", + "type": "text" + }, + { + "bbox": [ + 414, + 312, + 429, + 322 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 309, + 506, + 324 + ], + "score": 1.0, + "content": ", the better pruning", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 319, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 506, + 336 + ], + "score": 1.0, + "content": "strategy is to keep the hard (easy) examples. C: Color indicates difference in test error in keeping", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 333, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 345 + ], + "score": 1.0, + "content": "hard versus easy examples, revealing the change in strategy in (B). D: We tested this prediction on a", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "score": 1.0, + "content": "ResNet18 trained on CIFAR-10, finding remarkably the same shift in optimal pruning strategy under", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 353, + 506, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 315, + 368 + ], + "score": 1.0, + "content": "the EL2N metric. E: Test accuracy as a function of", + "type": "text" + }, + { + "bbox": [ + 316, + 355, + 323, + 366 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 353, + 341, + 368 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 341, + 355, + 365, + 366 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 353, + 433, + 368 + ], + "score": 1.0, + "content": ". For every fixed", + "type": "text" + }, + { + "bbox": [ + 433, + 355, + 457, + 366 + ], + "score": 0.9, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 353, + 506, + 368 + ], + "score": 1.0, + "content": ", there is an", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 365, + 330, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 139, + 378 + ], + "score": 1.0, + "content": "optimal", + "type": "text" + }, + { + "bbox": [ + 140, + 365, + 155, + 378 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 366, + 230, + 378 + ], + "score": 1.0, + "content": "(purple curve). F:", + "type": "text" + }, + { + "bbox": [ + 230, + 365, + 267, + 377 + ], + "score": 0.92, + "content": "I ( \\dot { \\alpha } _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 366, + 319, + 378 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 319, + 366, + 326, + 377 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 366, + 330, + 378 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 490 + ], + "lines": [ + { + "bbox": [ + 106, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 128, + 415 + ], + "score": 1.0, + "content": "from", + "type": "text" + }, + { + "bbox": [ + 129, + 402, + 144, + 414 + ], + "score": 0.85, + "content": "3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 402, + 155, + 415 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 156, + 402, + 171, + 414 + ], + "score": 0.86, + "content": "2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "might require an order of magnitude more data, compute, or energy. In language", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 421, + 426 + ], + "score": 1.0, + "content": "modeling with large transformers, a drop in cross entropy loss from about 3.4 to", + "type": "text" + }, + { + "bbox": [ + 422, + 413, + 457, + 424 + ], + "score": 0.4, + "content": "2 . 8 \\mathrm { n a t s } ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 414, + 493, + 426 + ], + "score": 1.0, + "content": "requires", + "type": "text" + }, + { + "bbox": [ + 493, + 414, + 505, + 424 + ], + "score": 0.32, + "content": "I O", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 505, + 437 + ], + "score": 1.0, + "content": "times more training data (Fig. 1 in [2]). Also, for large vision transformers, an additional 2 billion", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 506, + 448 + ], + "score": 1.0, + "content": "pre-training data points (starting from 1 billion) leads to an accuracy gain on ImageNet of a few", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 447, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 506, + 459 + ], + "score": 1.0, + "content": "percentage points (Fig. 1 in [7]). Here we ask whether we might be able to do better. For example,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 470 + ], + "score": 1.0, + "content": "can we achieve exponential scaling instead, with a good strategy for selecting training examples?", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 468, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 357, + 481 + ], + "score": 1.0, + "content": "Such vastly superior scaling would mean that we could go from", + "type": "text" + }, + { + "bbox": [ + 358, + 468, + 372, + 479 + ], + "score": 0.87, + "content": "3 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 468, + 383, + 481 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 383, + 468, + 398, + 479 + ], + "score": 0.87, + "content": "2 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 468, + 505, + 481 + ], + "score": 1.0, + "content": "error by only adding a few", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 479, + 437, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 338, + 491 + ], + "score": 1.0, + "content": "carefully chosen training examples, rather than collecting", + "type": "text" + }, + { + "bbox": [ + 338, + 479, + 357, + 490 + ], + "score": 0.87, + "content": "1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 479, + 437, + 491 + ], + "score": 1.0, + "content": "more random ones.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "Focusing on scaling of performance with training dataset size, we demonstrate that exponential", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "scaling is possible, both in theory and practice. The key idea is that power law scaling of error", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 517, + 505, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 530 + ], + "score": 1.0, + "content": "with respect to data suggests that many training examples are highly redundant. Thus one should", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 529, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 541 + ], + "score": 1.0, + "content": "in principle be able to prune training datasets to much smaller sizes and train on the smaller pruned", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "datasets without sacrificing performance. Indeed some recent works [9, 10, 11] have demonstrated", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "this possibility by suggesting various metrics to sort training examples in order of their difficulty or", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "importance, ranging from easy or redundant examples to hard or important ones, and pruning datasets", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "score": 1.0, + "content": "by retaining some fraction of the hardest examples. However, these works leave open fundamental", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "theoretical and empirical questions: When and why is successful data pruning possible? What are", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "score": 1.0, + "content": "good metrics and strategies for data pruning? Can such strategies beat power law scaling? Can they", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "score": 1.0, + "content": "scale to ImageNet? Can we leverage large unlabeled datasets to successfully prune labeled datasets?", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 615, + 479, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 479, + 628 + ], + "score": 1.0, + "content": "We address these questions through both theory and experiment. Our main contributions are:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 131, + 640, + 504, + 684 + ], + "lines": [ + { + "bbox": [ + 130, + 641, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 130, + 641, + 505, + 652 + ], + "score": 1.0, + "content": "1. Employing statistical mechanics, we develop a new analytic theory of data pruning in the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 141, + 651, + 506, + 663 + ], + "spans": [ + { + "bbox": [ + 141, + 651, + 506, + 663 + ], + "score": 1.0, + "content": "student-teacher setting for perceptron learning, where examples are pruned based on their", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 141, + 662, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 141, + 662, + 505, + 675 + ], + "score": 1.0, + "content": "teacher margin, with large (small) margins corresponding to easy (hard) examples. Our", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 674, + 503, + 685 + ], + "spans": [ + { + "bbox": [ + 142, + 674, + 503, + 685 + ], + "score": 1.0, + "content": "theory quantitatively matches numerical experiments and reveals two striking predictions:", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 701, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "score": 1.0, + "content": "2However, note that nats is on a logarithmic scale and and small improvements in nats can lead to large", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 711, + 237, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 237, + 722 + ], + "score": 1.0, + "content": "improvements in downstream tasks.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 753 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 75, + 503, + 250 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 75, + 503, + 250 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 75, + 503, + 250 + ], + "spans": [ + { + "bbox": [ + 110, + 75, + 503, + 250 + ], + "score": 0.976, + "type": "image", + "image_path": "f4951b0b0544dc88c37572ef6cd5e8307cf709eff161b62fe14d4d6cb443efed.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 75, + 503, + 133.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 133.33333333333334, + 503, + 191.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 191.66666666666669, + 503, + 250.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 256, + 505, + 376 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 255, + 506, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 506, + 269 + ], + "score": 1.0, + "content": "Figure 1: Our analytic theory of data pruning predicts that power law scaling of test error with respect", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 104, + 266, + 506, + 280 + ], + "spans": [ + { + "bbox": [ + 104, + 266, + 347, + 280 + ], + "score": 1.0, + "content": "to dataset size can be beaten. A: Test error as a function of", + "type": "text" + }, + { + "bbox": [ + 347, + 267, + 405, + 279 + ], + "score": 0.93, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 266, + 426, + 280 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 426, + 267, + 451, + 277 + ], + "score": 0.9, + "content": "\\theta = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 266, + 506, + 280 + ], + "score": 1.0, + "content": ". We observe", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 277, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 506, + 289 + ], + "score": 1.0, + "content": "an excellent match between our analytic theory (solid curves) and numerical simulations (dots) of", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 243, + 301 + ], + "score": 1.0, + "content": "perceptron learning at parameters", + "type": "text" + }, + { + "bbox": [ + 244, + 289, + 274, + 299 + ], + "score": 0.86, + "content": "{ \\bf N } = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 289, + 300, + 301 + ], + "score": 1.0, + "content": "(here:", + "type": "text" + }, + { + "bbox": [ + 301, + 289, + 331, + 299 + ], + "score": 0.85, + "content": "{ \\bf N } = 2 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "constant throughout figure). The red curve", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 297, + 503, + 315 + ], + "spans": [ + { + "bbox": [ + 104, + 297, + 256, + 315 + ], + "score": 1.0, + "content": "indicates the Pareto optimal test error", + "type": "text" + }, + { + "bbox": [ + 257, + 302, + 263, + 309 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 297, + 405, + 315 + ], + "score": 1.0, + "content": "achievable from a tradeoff between", + "type": "text" + }, + { + "bbox": [ + 406, + 301, + 421, + 311 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 297, + 439, + 315 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 439, + 300, + 446, + 311 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 297, + 479, + 315 + ], + "score": 1.0, + "content": "at fixed", + "type": "text" + }, + { + "bbox": [ + 479, + 301, + 503, + 312 + ], + "score": 0.73, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 309, + 506, + 324 + ], + "spans": [ + { + "bbox": [ + 104, + 309, + 413, + 324 + ], + "score": 1.0, + "content": "B: We find that when data is abundant (scarce) corresponding to large (small)", + "type": "text" + }, + { + "bbox": [ + 414, + 312, + 429, + 322 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 309, + 506, + 324 + ], + "score": 1.0, + "content": ", the better pruning", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 319, + 506, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 506, + 336 + ], + "score": 1.0, + "content": "strategy is to keep the hard (easy) examples. C: Color indicates difference in test error in keeping", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 333, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 506, + 345 + ], + "score": 1.0, + "content": "hard versus easy examples, revealing the change in strategy in (B). D: We tested this prediction on a", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 356 + ], + "score": 1.0, + "content": "ResNet18 trained on CIFAR-10, finding remarkably the same shift in optimal pruning strategy under", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 353, + 506, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 315, + 368 + ], + "score": 1.0, + "content": "the EL2N metric. E: Test accuracy as a function of", + "type": "text" + }, + { + "bbox": [ + 316, + 355, + 323, + 366 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 353, + 341, + 368 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 341, + 355, + 365, + 366 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 353, + 433, + 368 + ], + "score": 1.0, + "content": ". For every fixed", + "type": "text" + }, + { + "bbox": [ + 433, + 355, + 457, + 366 + ], + "score": 0.9, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 353, + 506, + 368 + ], + "score": 1.0, + "content": ", there is an", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 365, + 330, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 139, + 378 + ], + "score": 1.0, + "content": "optimal", + "type": "text" + }, + { + "bbox": [ + 140, + 365, + 155, + 378 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 156, + 366, + 230, + 378 + ], + "score": 1.0, + "content": "(purple curve). F:", + "type": "text" + }, + { + "bbox": [ + 230, + 365, + 267, + 377 + ], + "score": 0.92, + "content": "I ( \\dot { \\alpha } _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 366, + 319, + 378 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 319, + 366, + 326, + 377 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 366, + 330, + 378 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 8 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 490 + ], + "lines": [], + "index": 17.5, + "bbox_fs": [ + 105, + 402, + 506, + 491 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "Focusing on scaling of performance with training dataset size, we demonstrate that exponential", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "scaling is possible, both in theory and practice. The key idea is that power law scaling of error", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 517, + 505, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 505, + 530 + ], + "score": 1.0, + "content": "with respect to data suggests that many training examples are highly redundant. Thus one should", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 529, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 541 + ], + "score": 1.0, + "content": "in principle be able to prune training datasets to much smaller sizes and train on the smaller pruned", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "datasets without sacrificing performance. Indeed some recent works [9, 10, 11] have demonstrated", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "this possibility by suggesting various metrics to sort training examples in order of their difficulty or", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 574 + ], + "score": 1.0, + "content": "importance, ranging from easy or redundant examples to hard or important ones, and pruning datasets", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "score": 1.0, + "content": "by retaining some fraction of the hardest examples. However, these works leave open fundamental", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "theoretical and empirical questions: When and why is successful data pruning possible? What are", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "score": 1.0, + "content": "good metrics and strategies for data pruning? Can such strategies beat power law scaling? Can they", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 617 + ], + "score": 1.0, + "content": "scale to ImageNet? Can we leverage large unlabeled datasets to successfully prune labeled datasets?", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 615, + 479, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 479, + 628 + ], + "score": 1.0, + "content": "We address these questions through both theory and experiment. Our main contributions are:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 496, + 506, + 628 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 640, + 504, + 684 + ], + "lines": [ + { + "bbox": [ + 130, + 641, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 130, + 641, + 505, + 652 + ], + "score": 1.0, + "content": "1. Employing statistical mechanics, we develop a new analytic theory of data pruning in the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 141, + 651, + 506, + 663 + ], + "spans": [ + { + "bbox": [ + 141, + 651, + 506, + 663 + ], + "score": 1.0, + "content": "student-teacher setting for perceptron learning, where examples are pruned based on their", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 141, + 662, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 141, + 662, + 505, + 675 + ], + "score": 1.0, + "content": "teacher margin, with large (small) margins corresponding to easy (hard) examples. Our", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 674, + 503, + 685 + ], + "spans": [ + { + "bbox": [ + 142, + 674, + 503, + 685 + ], + "score": 1.0, + "content": "theory quantitatively matches numerical experiments and reveals two striking predictions:", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 130, + 641, + 506, + 685 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 145, + 73, + 506, + 119 + ], + "lines": [ + { + "bbox": [ + 145, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 145, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "(a) The optimal pruning strategy changes depending on the amount of initial data; with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 162, + 84, + 462, + 96 + ], + "spans": [ + { + "bbox": [ + 162, + 84, + 462, + 96 + ], + "score": 1.0, + "content": "abundant (scarce) initial data, one should retain only hard (easy) examples.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 145, + 96, + 506, + 110 + ], + "spans": [ + { + "bbox": [ + 145, + 96, + 506, + 110 + ], + "score": 1.0, + "content": "(b) Exponential scaling is possible with respect to pruned dataset size provided one chooses", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 162, + 108, + 485, + 119 + ], + "spans": [ + { + "bbox": [ + 162, + 108, + 485, + 119 + ], + "score": 1.0, + "content": "an increasing Pareto optimal pruning fraction as a function of initial dataset size.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 132, + 123, + 505, + 167 + ], + "lines": [ + { + "bbox": [ + 129, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 129, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "2. We show that the two striking predictions derived from theory hold also in practice in much", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 132, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 141, + 132, + 506, + 147 + ], + "score": 1.0, + "content": "more general settings. Indeed we empirically demonstrate signatures of exponential scaling", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 145, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 141, + 145, + 507, + 157 + ], + "score": 1.0, + "content": "of error with respect to pruned dataset size for ResNets trained from scratch on SVHN,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 155, + 451, + 168 + ], + "spans": [ + { + "bbox": [ + 141, + 155, + 451, + 168 + ], + "score": 1.0, + "content": "CIFAR-10 and ImageNet, and Vision Transformers fine-tuned on CIFAR-10.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 130, + 170, + 505, + 203 + ], + "lines": [ + { + "bbox": [ + 128, + 169, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 128, + 169, + 506, + 183 + ], + "score": 1.0, + "content": "3. Motivated by the importance of finding good quality metrics for data pruning, we perform a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 181, + 506, + 194 + ], + "spans": [ + { + "bbox": [ + 141, + 181, + 506, + 194 + ], + "score": 1.0, + "content": "large scale benchmarking study of 10 different data pruning metrics at scale on ImageNet,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 192, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 142, + 192, + 506, + 205 + ], + "score": 1.0, + "content": "finding that most perform poorly, with the exception of the most compute intensive metrics.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 130, + 207, + 505, + 262 + ], + "lines": [ + { + "bbox": [ + 129, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 129, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "4. We leveraged self-supervised learning (SSL) to developed a new, cheap unsupervised data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 218, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 141, + 218, + 506, + 230 + ], + "score": 1.0, + "content": "pruning metric that does not require labels, unlike prior metrics. We show this unsupervised", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 230, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 505, + 240 + ], + "score": 1.0, + "content": "metric performs comparably to the best supervised pruning metrics that require labels and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 238, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 238, + 506, + 254 + ], + "score": 1.0, + "content": "much more compute. This result opens the door to the exciting possibility of leveraging", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 251, + 471, + 263 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 471, + 263 + ], + "score": 1.0, + "content": "pre-trained foundation models to prune new datasets even before they are labeled.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 272, + 505, + 338 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "Overall these results shed theoretical and empirical insights into the nature of data in deep learning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 282, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 296 + ], + "score": 1.0, + "content": "and our ability to prune it, and suggest our current practice of collecting extremely large datasets may", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "be highly inefficient. Our initial results in beating power law scaling motivate further studies and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "investments in not just inefficently collecting large amounts of random data, but rather, intelligently", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "score": 1.0, + "content": "collecting much smaller amounts of carefully selected data, potentially leading to the creation and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 325, + 413, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 413, + 339 + ], + "score": 1.0, + "content": "dissemination of foundation datasets, in addition to foundation models [12].", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 108, + 353, + 280, + 367 + ], + "lines": [ + { + "bbox": [ + 104, + 353, + 281, + 370 + ], + "spans": [ + { + "bbox": [ + 104, + 353, + 281, + 370 + ], + "score": 1.0, + "content": "2 Background and related work", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 378, + 504, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "Our work brings together 3 largely disparate strands of intellectual inquiry in machine learning: (1)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "explorations of different metrics for quantifying differences between individual training examples;", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 400, + 495, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 495, + 414 + ], + "score": 1.0, + "content": "(2) the empirical observation of neural scaling laws; and (3) the statistical mechanics of learning.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 107, + 424, + 387, + 436 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 389, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 389, + 439 + ], + "score": 1.0, + "content": "2.1 Pruning metrics: not all training examples are created equal", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 488 + ], + "lines": [ + { + "bbox": [ + 106, + 445, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 456 + ], + "score": 1.0, + "content": "Several recent works have explored various metrics for quantifying individual differences between", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 506, + 469 + ], + "score": 1.0, + "content": "data points. To describe these metrics in a uniform manner, we will think of all of them as ordering", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "data points by their difficulty, ranging from “easiest” to “hardest.” When these metrics have been", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 477, + 493, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 493, + 491 + ], + "score": 1.0, + "content": "used for data pruning, the hardest examples are retained, while the easiest ones are pruned away.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 506, + 513 + ], + "score": 1.0, + "content": "EL2N scores. For example [10] trained small ensembles (of about 10) networks for a very short", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 419, + 525 + ], + "score": 1.0, + "content": "time (about 10 epochs) and computed for every training example the average", + "type": "text" + }, + { + "bbox": [ + 420, + 512, + 432, + 523 + ], + "score": 0.88, + "content": "L _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 511, + 506, + 525 + ], + "score": 1.0, + "content": "norm of the error", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "score": 1.0, + "content": "vector (EL2N score). Data pruning by retaining only the hardest examples with largest error enabled", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 531, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 225, + 547 + ], + "score": 1.0, + "content": "training from scratch on only", + "type": "text" + }, + { + "bbox": [ + 225, + 533, + 245, + 544 + ], + "score": 0.9, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 531, + 263, + 547 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 263, + 533, + 283, + 544 + ], + "score": 0.89, + "content": "7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 531, + 505, + 547 + ], + "score": 1.0, + "content": "of CIFAR-10 and CIFAR-100 respectively without any", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "loss in final test accuracy. However the performance of EL2N on ImageNet has not yet been explored.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 505, + 622 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 507, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 507, + 582 + ], + "score": 1.0, + "content": "Forgetting scores and classification margins. [9] noticed that over the entire course of training,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "some examples are learned early and never forgotten, while others can be learned and unlearned (i.e.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 589, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 506, + 603 + ], + "score": 1.0, + "content": "forgotten) repeatedly. They developed a forgetting score which measures the degree of forgetting of", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "each example. Intuitively examples with low (high) forgetting scores can be thought of as easy (hard)", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 611, + 441, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 441, + 624 + ], + "score": 1.0, + "content": "examples. [9] explored data pruning using these metrics, but not at ImageNet scale.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 106, + 634, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "score": 1.0, + "content": "Memorization and influence. [13] defined a memorization score for each example, corresponding", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 646, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 658 + ], + "score": 1.0, + "content": "to how much the probability of predicting the correct label for the example increases when it is present", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 657, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 505, + 668 + ], + "score": 1.0, + "content": "in the training set relative to when it is absent; a large increase means the example must be memorized", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "(i.e. the remaining training data do not suffice to correctly learn this example). Additionally [13] also", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "considered an influence score that quantifies how much adding a particular example to the training", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "set increases the probability of the correct class label of a test example. Intuitively, low memorization", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "and influence scores correspond to easy examples that are redundant with the rest of the data, while", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "high scores correspond to hard examples that must be individually learned. [13] did not use these", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 309, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 145, + 73, + 506, + 119 + ], + "lines": [ + { + "bbox": [ + 145, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 145, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "(a) The optimal pruning strategy changes depending on the amount of initial data; with", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 84, + 462, + 96 + ], + "spans": [ + { + "bbox": [ + 162, + 84, + 462, + 96 + ], + "score": 1.0, + "content": "abundant (scarce) initial data, one should retain only hard (easy) examples.", + "type": "text" + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 96, + 506, + 110 + ], + "spans": [ + { + "bbox": [ + 145, + 96, + 506, + 110 + ], + "score": 1.0, + "content": "(b) Exponential scaling is possible with respect to pruned dataset size provided one chooses", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 108, + 485, + 119 + ], + "spans": [ + { + "bbox": [ + 162, + 108, + 485, + 119 + ], + "score": 1.0, + "content": "an increasing Pareto optimal pruning fraction as a function of initial dataset size.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + } + ], + "index": 1.5, + "bbox_fs": [ + 145, + 72, + 506, + 119 + ] + }, + { + "type": "text", + "bbox": [ + 132, + 123, + 505, + 167 + ], + "lines": [ + { + "bbox": [ + 129, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 129, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "2. We show that the two striking predictions derived from theory hold also in practice in much", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 132, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 141, + 132, + 506, + 147 + ], + "score": 1.0, + "content": "more general settings. Indeed we empirically demonstrate signatures of exponential scaling", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 145, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 141, + 145, + 507, + 157 + ], + "score": 1.0, + "content": "of error with respect to pruned dataset size for ResNets trained from scratch on SVHN,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 155, + 451, + 168 + ], + "spans": [ + { + "bbox": [ + 141, + 155, + 451, + 168 + ], + "score": 1.0, + "content": "CIFAR-10 and ImageNet, and Vision Transformers fine-tuned on CIFAR-10.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5, + "bbox_fs": [ + 129, + 122, + 507, + 168 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 170, + 505, + 203 + ], + "lines": [ + { + "bbox": [ + 128, + 169, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 128, + 169, + 506, + 183 + ], + "score": 1.0, + "content": "3. Motivated by the importance of finding good quality metrics for data pruning, we perform a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 181, + 506, + 194 + ], + "spans": [ + { + "bbox": [ + 141, + 181, + 506, + 194 + ], + "score": 1.0, + "content": "large scale benchmarking study of 10 different data pruning metrics at scale on ImageNet,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 142, + 192, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 142, + 192, + 506, + 205 + ], + "score": 1.0, + "content": "finding that most perform poorly, with the exception of the most compute intensive metrics.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 128, + 169, + 506, + 205 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 207, + 505, + 262 + ], + "lines": [ + { + "bbox": [ + 129, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 129, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "4. We leveraged self-supervised learning (SSL) to developed a new, cheap unsupervised data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 218, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 141, + 218, + 506, + 230 + ], + "score": 1.0, + "content": "pruning metric that does not require labels, unlike prior metrics. We show this unsupervised", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 230, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 505, + 240 + ], + "score": 1.0, + "content": "metric performs comparably to the best supervised pruning metrics that require labels and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 238, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 238, + 506, + 254 + ], + "score": 1.0, + "content": "much more compute. This result opens the door to the exciting possibility of leveraging", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 251, + 471, + 263 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 471, + 263 + ], + "score": 1.0, + "content": "pre-trained foundation models to prune new datasets even before they are labeled.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13, + "bbox_fs": [ + 129, + 207, + 506, + 263 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 272, + 505, + 338 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "Overall these results shed theoretical and empirical insights into the nature of data in deep learning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 282, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 296 + ], + "score": 1.0, + "content": "and our ability to prune it, and suggest our current practice of collecting extremely large datasets may", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "be highly inefficient. Our initial results in beating power law scaling motivate further studies and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "investments in not just inefficently collecting large amounts of random data, but rather, intelligently", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 505, + 327 + ], + "score": 1.0, + "content": "collecting much smaller amounts of carefully selected data, potentially leading to the creation and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 325, + 413, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 413, + 339 + ], + "score": 1.0, + "content": "dissemination of foundation datasets, in addition to foundation models [12].", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 270, + 506, + 339 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 353, + 280, + 367 + ], + "lines": [ + { + "bbox": [ + 104, + 353, + 281, + 370 + ], + "spans": [ + { + "bbox": [ + 104, + 353, + 281, + 370 + ], + "score": 1.0, + "content": "2 Background and related work", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 378, + 504, + 411 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 391 + ], + "score": 1.0, + "content": "Our work brings together 3 largely disparate strands of intellectual inquiry in machine learning: (1)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "explorations of different metrics for quantifying differences between individual training examples;", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 400, + 495, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 495, + 414 + ], + "score": 1.0, + "content": "(2) the empirical observation of neural scaling laws; and (3) the statistical mechanics of learning.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 378, + 506, + 414 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 424, + 387, + 436 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 389, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 389, + 439 + ], + "score": 1.0, + "content": "2.1 Pruning metrics: not all training examples are created equal", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 488 + ], + "lines": [ + { + "bbox": [ + 106, + 445, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 445, + 505, + 456 + ], + "score": 1.0, + "content": "Several recent works have explored various metrics for quantifying individual differences between", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 506, + 469 + ], + "score": 1.0, + "content": "data points. To describe these metrics in a uniform manner, we will think of all of them as ordering", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "data points by their difficulty, ranging from “easiest” to “hardest.” When these metrics have been", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 477, + 493, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 493, + 491 + ], + "score": 1.0, + "content": "used for data pruning, the hardest examples are retained, while the easiest ones are pruned away.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 445, + 506, + 491 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 506, + 513 + ], + "score": 1.0, + "content": "EL2N scores. For example [10] trained small ensembles (of about 10) networks for a very short", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 511, + 506, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 419, + 525 + ], + "score": 1.0, + "content": "time (about 10 epochs) and computed for every training example the average", + "type": "text" + }, + { + "bbox": [ + 420, + 512, + 432, + 523 + ], + "score": 0.88, + "content": "L _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 511, + 506, + 525 + ], + "score": 1.0, + "content": "norm of the error", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "score": 1.0, + "content": "vector (EL2N score). Data pruning by retaining only the hardest examples with largest error enabled", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 531, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 225, + 547 + ], + "score": 1.0, + "content": "training from scratch on only", + "type": "text" + }, + { + "bbox": [ + 225, + 533, + 245, + 544 + ], + "score": 0.9, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 531, + 263, + 547 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 263, + 533, + 283, + 544 + ], + "score": 0.89, + "content": "7 5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 531, + 505, + 547 + ], + "score": 1.0, + "content": "of CIFAR-10 and CIFAR-100 respectively without any", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "loss in final test accuracy. However the performance of EL2N on ImageNet has not yet been explored.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 500, + 506, + 558 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 567, + 505, + 622 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 507, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 507, + 582 + ], + "score": 1.0, + "content": "Forgetting scores and classification margins. [9] noticed that over the entire course of training,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 591 + ], + "score": 1.0, + "content": "some examples are learned early and never forgotten, while others can be learned and unlearned (i.e.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 589, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 589, + 506, + 603 + ], + "score": 1.0, + "content": "forgotten) repeatedly. They developed a forgetting score which measures the degree of forgetting of", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "each example. Intuitively examples with low (high) forgetting scores can be thought of as easy (hard)", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 611, + 441, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 441, + 624 + ], + "score": 1.0, + "content": "examples. [9] explored data pruning using these metrics, but not at ImageNet scale.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 566, + 507, + 624 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 634, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 648 + ], + "score": 1.0, + "content": "Memorization and influence. [13] defined a memorization score for each example, corresponding", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 646, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 658 + ], + "score": 1.0, + "content": "to how much the probability of predicting the correct label for the example increases when it is present", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 657, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 505, + 668 + ], + "score": 1.0, + "content": "in the training set relative to when it is absent; a large increase means the example must be memorized", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "(i.e. the remaining training data do not suffice to correctly learn this example). Additionally [13] also", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "considered an influence score that quantifies how much adding a particular example to the training", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "set increases the probability of the correct class label of a test example. Intuitively, low memorization", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "and influence scores correspond to easy examples that are redundant with the rest of the data, while", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "high scores correspond to hard examples that must be individually learned. [13] did not use these", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "scores for data pruning as their computation is expensive. We note since memorization explicitly", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "approximates the increase in test loss due to removing each individual example, it is likely to be a", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 359, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 359, + 107 + ], + "score": 1.0, + "content": "good pruning metric (though it does not consider interactions).", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 633, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 73, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "scores for data pruning as their computation is expensive. We note since memorization explicitly", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "approximates the increase in test loss due to removing each individual example, it is likely to be a", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 359, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 359, + 107 + ], + "score": 1.0, + "content": "good pruning metric (though it does not consider interactions).", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 117, + 505, + 216 + ], + "lines": [ + { + "bbox": [ + 106, + 117, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 505, + 130 + ], + "score": 1.0, + "content": "Ensemble active learning. Active learning iterates between training a model and selecting new", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "inputs to be labeled [14, 15, 16, 17, 18]. In contrast, we focus on data pruning: one-shot selection", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 138, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 505, + 152 + ], + "score": 1.0, + "content": "of a data subset sufficient to train to high accuracy from scratch. A variety of coreset algorithms", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "score": 1.0, + "content": "(e.g. [19]) have been proposed for this, but their computation is expensive, and so data-pruning has", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "been less explored at scale on ImageNet. An early clustering approach [20] allowed training on", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 171, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 126, + 183 + ], + "score": 0.88, + "content": "9 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 171, + 410, + 186 + ], + "score": 1.0, + "content": "of ImageNet without sacrificing accuracy. Notably [11] reduced this to", + "type": "text" + }, + { + "bbox": [ + 410, + 172, + 429, + 183 + ], + "score": 0.9, + "content": "8 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 171, + 505, + 186 + ], + "score": 1.0, + "content": "by training a large", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 183, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 505, + 196 + ], + "score": 1.0, + "content": "ensemble of networks on ImageNet and using ensemble uncertainty to define the difficulty of each", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "score": 1.0, + "content": "example, with low (high) uncertainty corresponding to easy (hard) examples. We will show how to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 205, + 463, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 463, + 218 + ], + "score": 1.0, + "content": "achieve similar pruning performance without labels or the need to train a large ensemble.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 228, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "Diverse ensembles (DDD). [21] assigned a score to every ImageNet image, given by the number of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "score": 1.0, + "content": "models in a diverse ensemble (10 models) that misclassified the image. Intuitively, low (high) scores", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 250, + 498, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 498, + 263 + ], + "score": 1.0, + "content": "correspond to easy (hard) examples. The pruning performance of this metric remains unexplored.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 272, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 286 + ], + "score": 1.0, + "content": "Summary. We note: (1) only one of these metrics has tested well for its efficacy in data pruning", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 284, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 505, + 295 + ], + "score": 1.0, + "content": "at scale on ImageNet; (2) all of these metrics require label information; (3) there is no theory of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 294, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 308 + ], + "score": 1.0, + "content": "when and why data pruning is possible for any of these metrics; and (4) none of these works suggest", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 306, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 318 + ], + "score": 1.0, + "content": "the possibility of exponential scaling. We thus go beyond this prior work by benchmarking the data", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 329 + ], + "score": 1.0, + "content": "pruning efficacy of not only these metrics but also a new unsupervised metric we introduce that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "score": 1.0, + "content": "does not require label information, all at scale on ImageNet. We also develop an analytic theory for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "data-pruning for the margin metric that predicts not only the possibility of exponential scaling but", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 349, + 488, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 488, + 362 + ], + "score": 1.0, + "content": "also the novel finding that retaining easy instead of hard examples is better when data is scarce.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 107, + 374, + 345, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 345, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 345, + 388 + ], + "score": 1.0, + "content": "2.2 Neural scaling laws and their potential inefficiency", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 393, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 374, + 406 + ], + "score": 1.0, + "content": "Recent work [1, 2, 3, 4, 5, 6, 7, 8] has demonstrated that test loss", + "type": "text" + }, + { + "bbox": [ + 375, + 394, + 383, + 403 + ], + "score": 0.74, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "often falls off as a power law", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 403, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 296, + 417 + ], + "score": 1.0, + "content": "with different resources like model parameters", + "type": "text" + }, + { + "bbox": [ + 297, + 405, + 313, + 415 + ], + "score": 0.69, + "content": "( N )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 403, + 436, + 417 + ], + "score": 1.0, + "content": ", number of training examples", + "type": "text" + }, + { + "bbox": [ + 436, + 405, + 451, + 415 + ], + "score": 0.76, + "content": "( P )", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 403, + 506, + 417 + ], + "score": 1.0, + "content": ", and amount", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 414, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 156, + 429 + ], + "score": 1.0, + "content": "of compute", + "type": "text" + }, + { + "bbox": [ + 157, + 416, + 172, + 426 + ], + "score": 0.7, + "content": "( C )", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 414, + 280, + 429 + ], + "score": 1.0, + "content": ". However, the exponents", + "type": "text" + }, + { + "bbox": [ + 280, + 417, + 287, + 425 + ], + "score": 0.74, + "content": "\\nu", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 414, + 505, + 429 + ], + "score": 1.0, + "content": "of these power laws are often close to 0, suggesting", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "potentially inefficient use of resources. For example, for large models with lots of compute, so", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 436, + 503, + 450 + ], + "spans": [ + { + "bbox": [ + 104, + 436, + 462, + 450 + ], + "score": 1.0, + "content": "that the amount of training data constitutes a performance bottleneck, the loss scales as", + "type": "text" + }, + { + "bbox": [ + 462, + 437, + 503, + 447 + ], + "score": 0.91, + "content": " { \\mathcal { L } } \\approx P ^ { - \\nu }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 353, + 460 + ], + "score": 1.0, + "content": "Specifically for a large transformer based language model,", + "type": "text" + }, + { + "bbox": [ + 354, + 448, + 400, + 459 + ], + "score": 0.88, + "content": "\\nu = 0 . 0 9 5", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 449, + 506, + 460 + ], + "score": 1.0, + "content": ", which implies an order", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 506, + 472 + ], + "score": 1.0, + "content": "of magnitude increase in training data drops cross-entropy loss by only about 0.6 nats (Fig. 1 in", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 304, + 483 + ], + "score": 1.0, + "content": "[2]). In neural machine translation experiments", + "type": "text" + }, + { + "bbox": [ + 304, + 472, + 312, + 480 + ], + "score": 0.72, + "content": "\\nu", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "varies across language pairs from 0.35 to 0.48", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 480, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 403, + 494 + ], + "score": 1.0, + "content": "(Table 1 in [5]). Interestingly, [8] explored a fixed computation budget", + "type": "text" + }, + { + "bbox": [ + 403, + 482, + 413, + 491 + ], + "score": 0.81, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 480, + 505, + 494 + ], + "score": 1.0, + "content": "and optimized jointly", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 172, + 505 + ], + "score": 1.0, + "content": "over model size", + "type": "text" + }, + { + "bbox": [ + 172, + 492, + 182, + 502 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 491, + 266, + 505 + ], + "score": 1.0, + "content": "and training set size", + "type": "text" + }, + { + "bbox": [ + 266, + 492, + 275, + 502 + ], + "score": 0.79, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 491, + 387, + 505 + ], + "score": 1.0, + "content": ", revealing that scaling both", + "type": "text" + }, + { + "bbox": [ + 387, + 492, + 397, + 502 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 491, + 415, + 505 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 492, + 424, + 502 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 491, + 505, + 505 + ], + "score": 1.0, + "content": "commensurately as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 107, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 115, + 513 + ], + "score": 0.79, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "increases is compute optimal, and can yield smaller high performing models (trained on more", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 435, + 526 + ], + "score": 1.0, + "content": "data) than previous work. Nevertheless, for a transformer based language model, a", + "type": "text" + }, + { + "bbox": [ + 435, + 514, + 459, + 524 + ], + "score": 0.89, + "content": "1 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 513, + 505, + 526 + ], + "score": 1.0, + "content": "increase in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 215, + 537 + ], + "score": 1.0, + "content": "compute, corresponding to", + "type": "text" + }, + { + "bbox": [ + 215, + 525, + 234, + 535 + ], + "score": 0.88, + "content": "1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 525, + 505, + 537 + ], + "score": 1.0, + "content": "increases in both model size and training set size, leads to a drop in", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "cross-entropy loss of only about 0.5 nats (Fig. 2 in [8]). Similar slow scaling holds for large vision", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "transformers where adding 2 billion pre-training images reduces ImageNet performance by a few", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 557, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 104, + 557, + 506, + 570 + ], + "score": 1.0, + "content": "percentage points (Fig. 1 in [7]). While all of these results constitute significant improvements in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "performance, they do come at a substantial resource cost whose fundamental origin arises from power", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 506, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 593 + ], + "score": 1.0, + "content": "law scaling with small exponents. Recent theoretical works [22, 23, 24] have argued that the power", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 506, + 603 + ], + "score": 1.0, + "content": "law exponent is governed by the dimension of a data manifold from which training examples are", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "uniformly drawn. Here we explore whether we can beat power law scaling through careful data", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 613, + 146, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 146, + 623 + ], + "score": 1.0, + "content": "selection.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 34 + }, + { + "type": "title", + "bbox": [ + 107, + 636, + 317, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 634, + 318, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 634, + 318, + 651 + ], + "score": 1.0, + "content": "2.3 Statistical mechanics of perceptron learning", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 670 + ], + "score": 1.0, + "content": "Statistical mechanics has long played a role in analyzing machine learning problems (see e.g.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "[25, 26, 27, 28] for reviews). One of the most fundamental applications is perceptron learning in", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "the student-teacher setting [29, 30], in which random i.i.d. Gaussian inputs are labeled by a teacher", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "perceptron to construct a training set. The test error for another student perceptron learning from this", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 321, + 712 + ], + "score": 1.0, + "content": "training set then scales as a power law with exponent", + "type": "text" + }, + { + "bbox": [ + 322, + 700, + 335, + 711 + ], + "score": 0.75, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "for such data. Such perceptrons have also", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "been analyzed in an active learning setting where the learner is free to design any new input to be", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 48.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 11, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 73, + 504, + 105 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 73, + 506, + 107 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 117, + 505, + 216 + ], + "lines": [ + { + "bbox": [ + 106, + 117, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 505, + 130 + ], + "score": 1.0, + "content": "Ensemble active learning. Active learning iterates between training a model and selecting new", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "inputs to be labeled [14, 15, 16, 17, 18]. In contrast, we focus on data pruning: one-shot selection", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 138, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 505, + 152 + ], + "score": 1.0, + "content": "of a data subset sufficient to train to high accuracy from scratch. A variety of coreset algorithms", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "score": 1.0, + "content": "(e.g. [19]) have been proposed for this, but their computation is expensive, and so data-pruning has", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 505, + 175 + ], + "score": 1.0, + "content": "been less explored at scale on ImageNet. An early clustering approach [20] allowed training on", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 171, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 126, + 183 + ], + "score": 0.88, + "content": "9 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 171, + 410, + 186 + ], + "score": 1.0, + "content": "of ImageNet without sacrificing accuracy. Notably [11] reduced this to", + "type": "text" + }, + { + "bbox": [ + 410, + 172, + 429, + 183 + ], + "score": 0.9, + "content": "8 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 171, + 505, + 186 + ], + "score": 1.0, + "content": "by training a large", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 183, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 505, + 196 + ], + "score": 1.0, + "content": "ensemble of networks on ImageNet and using ensemble uncertainty to define the difficulty of each", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 194, + 506, + 207 + ], + "score": 1.0, + "content": "example, with low (high) uncertainty corresponding to easy (hard) examples. We will show how to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 205, + 463, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 463, + 218 + ], + "score": 1.0, + "content": "achieve similar pruning performance without labels or the need to train a large ensemble.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 117, + 506, + 218 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 228, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 241 + ], + "score": 1.0, + "content": "Diverse ensembles (DDD). [21] assigned a score to every ImageNet image, given by the number of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "score": 1.0, + "content": "models in a diverse ensemble (10 models) that misclassified the image. Intuitively, low (high) scores", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 250, + 498, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 498, + 263 + ], + "score": 1.0, + "content": "correspond to easy (hard) examples. The pruning performance of this metric remains unexplored.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 227, + 505, + 263 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 272, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 286 + ], + "score": 1.0, + "content": "Summary. We note: (1) only one of these metrics has tested well for its efficacy in data pruning", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 284, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 505, + 295 + ], + "score": 1.0, + "content": "at scale on ImageNet; (2) all of these metrics require label information; (3) there is no theory of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 294, + 506, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 308 + ], + "score": 1.0, + "content": "when and why data pruning is possible for any of these metrics; and (4) none of these works suggest", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 306, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 318 + ], + "score": 1.0, + "content": "the possibility of exponential scaling. We thus go beyond this prior work by benchmarking the data", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 506, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 329 + ], + "score": 1.0, + "content": "pruning efficacy of not only these metrics but also a new unsupervised metric we introduce that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "score": 1.0, + "content": "does not require label information, all at scale on ImageNet. We also develop an analytic theory for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "data-pruning for the margin metric that predicts not only the possibility of exponential scaling but", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 349, + 488, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 488, + 362 + ], + "score": 1.0, + "content": "also the novel finding that retaining easy instead of hard examples is better when data is scarce.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 272, + 506, + 362 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 374, + 345, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 371, + 345, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 345, + 388 + ], + "score": 1.0, + "content": "2.2 Neural scaling laws and their potential inefficiency", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 393, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 374, + 406 + ], + "score": 1.0, + "content": "Recent work [1, 2, 3, 4, 5, 6, 7, 8] has demonstrated that test loss", + "type": "text" + }, + { + "bbox": [ + 375, + 394, + 383, + 403 + ], + "score": 0.74, + "content": "\\mathcal { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "often falls off as a power law", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 403, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 296, + 417 + ], + "score": 1.0, + "content": "with different resources like model parameters", + "type": "text" + }, + { + "bbox": [ + 297, + 405, + 313, + 415 + ], + "score": 0.69, + "content": "( N )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 403, + 436, + 417 + ], + "score": 1.0, + "content": ", number of training examples", + "type": "text" + }, + { + "bbox": [ + 436, + 405, + 451, + 415 + ], + "score": 0.76, + "content": "( P )", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 403, + 506, + 417 + ], + "score": 1.0, + "content": ", and amount", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 414, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 156, + 429 + ], + "score": 1.0, + "content": "of compute", + "type": "text" + }, + { + "bbox": [ + 157, + 416, + 172, + 426 + ], + "score": 0.7, + "content": "( C )", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 414, + 280, + 429 + ], + "score": 1.0, + "content": ". However, the exponents", + "type": "text" + }, + { + "bbox": [ + 280, + 417, + 287, + 425 + ], + "score": 0.74, + "content": "\\nu", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 414, + 505, + 429 + ], + "score": 1.0, + "content": "of these power laws are often close to 0, suggesting", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "potentially inefficient use of resources. For example, for large models with lots of compute, so", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 436, + 503, + 450 + ], + "spans": [ + { + "bbox": [ + 104, + 436, + 462, + 450 + ], + "score": 1.0, + "content": "that the amount of training data constitutes a performance bottleneck, the loss scales as", + "type": "text" + }, + { + "bbox": [ + 462, + 437, + 503, + 447 + ], + "score": 0.91, + "content": " { \\mathcal { L } } \\approx P ^ { - \\nu }", + "type": "inline_equation" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 353, + 460 + ], + "score": 1.0, + "content": "Specifically for a large transformer based language model,", + "type": "text" + }, + { + "bbox": [ + 354, + 448, + 400, + 459 + ], + "score": 0.88, + "content": "\\nu = 0 . 0 9 5", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 449, + 506, + 460 + ], + "score": 1.0, + "content": ", which implies an order", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 106, + 459, + 506, + 472 + ], + "score": 1.0, + "content": "of magnitude increase in training data drops cross-entropy loss by only about 0.6 nats (Fig. 1 in", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 304, + 483 + ], + "score": 1.0, + "content": "[2]). In neural machine translation experiments", + "type": "text" + }, + { + "bbox": [ + 304, + 472, + 312, + 480 + ], + "score": 0.72, + "content": "\\nu", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "varies across language pairs from 0.35 to 0.48", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 480, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 403, + 494 + ], + "score": 1.0, + "content": "(Table 1 in [5]). Interestingly, [8] explored a fixed computation budget", + "type": "text" + }, + { + "bbox": [ + 403, + 482, + 413, + 491 + ], + "score": 0.81, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 480, + 505, + 494 + ], + "score": 1.0, + "content": "and optimized jointly", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 172, + 505 + ], + "score": 1.0, + "content": "over model size", + "type": "text" + }, + { + "bbox": [ + 172, + 492, + 182, + 502 + ], + "score": 0.77, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 491, + 266, + 505 + ], + "score": 1.0, + "content": "and training set size", + "type": "text" + }, + { + "bbox": [ + 266, + 492, + 275, + 502 + ], + "score": 0.79, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 491, + 387, + 505 + ], + "score": 1.0, + "content": ", revealing that scaling both", + "type": "text" + }, + { + "bbox": [ + 387, + 492, + 397, + 502 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 491, + 415, + 505 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 492, + 424, + 502 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 491, + 505, + 505 + ], + "score": 1.0, + "content": "commensurately as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 107, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 115, + 513 + ], + "score": 0.79, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "increases is compute optimal, and can yield smaller high performing models (trained on more", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 513, + 505, + 526 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 435, + 526 + ], + "score": 1.0, + "content": "data) than previous work. Nevertheless, for a transformer based language model, a", + "type": "text" + }, + { + "bbox": [ + 435, + 514, + 459, + 524 + ], + "score": 0.89, + "content": "1 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 513, + 505, + 526 + ], + "score": 1.0, + "content": "increase in", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 215, + 537 + ], + "score": 1.0, + "content": "compute, corresponding to", + "type": "text" + }, + { + "bbox": [ + 215, + 525, + 234, + 535 + ], + "score": 0.88, + "content": "1 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 525, + 505, + 537 + ], + "score": 1.0, + "content": "increases in both model size and training set size, leads to a drop in", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "cross-entropy loss of only about 0.5 nats (Fig. 2 in [8]). Similar slow scaling holds for large vision", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "transformers where adding 2 billion pre-training images reduces ImageNet performance by a few", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 557, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 104, + 557, + 506, + 570 + ], + "score": 1.0, + "content": "percentage points (Fig. 1 in [7]). While all of these results constitute significant improvements in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "performance, they do come at a substantial resource cost whose fundamental origin arises from power", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 577, + 506, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 593 + ], + "score": 1.0, + "content": "law scaling with small exponents. Recent theoretical works [22, 23, 24] have argued that the power", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 506, + 603 + ], + "score": 1.0, + "content": "law exponent is governed by the dimension of a data manifold from which training examples are", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "uniformly drawn. Here we explore whether we can beat power law scaling through careful data", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 613, + 146, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 146, + 623 + ], + "score": 1.0, + "content": "selection.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 34, + "bbox_fs": [ + 104, + 394, + 506, + 623 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 636, + 317, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 634, + 318, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 634, + 318, + 651 + ], + "score": 1.0, + "content": "2.3 Statistical mechanics of perceptron learning", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 506, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 506, + 670 + ], + "score": 1.0, + "content": "Statistical mechanics has long played a role in analyzing machine learning problems (see e.g.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "[25, 26, 27, 28] for reviews). One of the most fundamental applications is perceptron learning in", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "the student-teacher setting [29, 30], in which random i.i.d. Gaussian inputs are labeled by a teacher", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 689, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 701 + ], + "score": 1.0, + "content": "perceptron to construct a training set. The test error for another student perceptron learning from this", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 321, + 712 + ], + "score": 1.0, + "content": "training set then scales as a power law with exponent", + "type": "text" + }, + { + "bbox": [ + 322, + 700, + 335, + 711 + ], + "score": 0.75, + "content": "- 1", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "for such data. Such perceptrons have also", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "been analyzed in an active learning setting where the learner is free to design any new input to be", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "labeled [31, 32], rather than choose from a fixed set of inputs, as in data-pruning. Recent work [33]", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "has analyzed this scenario but focused on message passing algorithms that are tailored to the case of", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 107 + ], + "score": 1.0, + "content": "Gaussian inputs and perceptrons, and are hard to generalize to real world settings. In contrast we", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 501, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 501, + 118 + ], + "score": 1.0, + "content": "analyze margin based pruning algorithms that are used in practice in diverse settings, as in [9, 10].", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 48.5, + "bbox_fs": [ + 105, + 654, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "labeled [31, 32], rather than choose from a fixed set of inputs, as in data-pruning. Recent work [33]", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "has analyzed this scenario but focused on message passing algorithms that are tailored to the case of", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 505, + 107 + ], + "score": 1.0, + "content": "Gaussian inputs and perceptrons, and are hard to generalize to real world settings. In contrast we", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 501, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 501, + 118 + ], + "score": 1.0, + "content": "analyze margin based pruning algorithms that are used in practice in diverse settings, as in [9, 10].", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 106, + 132, + 304, + 146 + ], + "lines": [ + { + "bbox": [ + 104, + 129, + 306, + 149 + ], + "spans": [ + { + "bbox": [ + 104, + 129, + 306, + 149 + ], + "score": 1.0, + "content": "3 An analytic theory of data pruning", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 156, + 506, + 293 + ], + "lines": [ + { + "bbox": [ + 104, + 155, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 104, + 155, + 506, + 169 + ], + "score": 1.0, + "content": "To better understand data pruning, we employed the replica method from statistical mechanics [34] to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 168, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 106, + 168, + 506, + 180 + ], + "score": 1.0, + "content": "develop an analytic theory of pruning for the perceptron in the student-teacher setting [25] (see App. A", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 175, + 503, + 193 + ], + "spans": [ + { + "bbox": [ + 104, + 175, + 382, + 193 + ], + "score": 1.0, + "content": "for detailed derivations of all results). Consider a training dataset of", + "type": "text" + }, + { + "bbox": [ + 382, + 179, + 391, + 188 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 175, + 433, + 193 + ], + "score": 1.0, + "content": "examples", + "type": "text" + }, + { + "bbox": [ + 433, + 178, + 503, + 191 + ], + "score": 0.91, + "content": "\\{ { \\bf x } ^ { \\mu } , y ^ { \\mu } \\} _ { \\mu = 1 , \\dots , P }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 133, + 204 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 190, + 173, + 201 + ], + "score": 0.92, + "content": "\\mathbf { x } ^ { \\mu } \\in \\mathbb { R } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 188, + 428, + 204 + ], + "score": 1.0, + "content": "are i.i.d. zero mean unit variance random Gaussian inputs and", + "type": "text" + }, + { + "bbox": [ + 429, + 191, + 505, + 202 + ], + "score": 0.89, + "content": "y ^ { \\mu } = \\operatorname { s i g n } ( \\mathbf { T } \\cdot \\mathbf { x } ^ { \\mu } )", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 199, + 507, + 215 + ], + "spans": [ + { + "bbox": [ + 104, + 199, + 372, + 215 + ], + "score": 1.0, + "content": "are labels generated by a teacher perceptron with weight vector", + "type": "text" + }, + { + "bbox": [ + 372, + 201, + 411, + 211 + ], + "score": 0.91, + "content": "\\mathbf { T } \\in \\mathbf { \\mathbb { R } } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 199, + 507, + 215 + ], + "score": 1.0, + "content": ". We work in the high", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 102, + 206, + 510, + 231 + ], + "spans": [ + { + "bbox": [ + 102, + 206, + 243, + 231 + ], + "score": 1.0, + "content": "dimensional statistics limit where", + "type": "text" + }, + { + "bbox": [ + 243, + 213, + 290, + 223 + ], + "score": 0.9, + "content": "N , P \\to \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 206, + 342, + 231 + ], + "score": 1.0, + "content": "but the ratio", + "type": "text" + }, + { + "bbox": [ + 343, + 212, + 380, + 225 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { \\mathrm { t o t } } = \\frac { P } { N } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 206, + 510, + 231 + ], + "score": 1.0, + "content": "of the number of total training", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 234, + 236 + ], + "score": 1.0, + "content": "examples to parameters remains", + "type": "text" + }, + { + "bbox": [ + 235, + 224, + 256, + 235 + ], + "score": 0.9, + "content": "O ( 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 223, + 506, + 236 + ], + "score": 1.0, + "content": ". We then consider a pruning algorithm used in [9, 10], namely:", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 232, + 507, + 248 + ], + "spans": [ + { + "bbox": [ + 104, + 232, + 478, + 248 + ], + "score": 1.0, + "content": "(1) train a probe student perceptron for very few epochs on the training data, obtaining weights", + "type": "text" + }, + { + "bbox": [ + 478, + 235, + 502, + 246 + ], + "score": 0.89, + "content": "\\mathbf { J _ { \\mathrm { p r o b e } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 232, + 507, + 248 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 201, + 259 + ], + "score": 1.0, + "content": "(2) compute the margin", + "type": "text" + }, + { + "bbox": [ + 201, + 245, + 289, + 257 + ], + "score": 0.94, + "content": "m ^ { \\mu } = { \\bf J } _ { \\mathrm { p r o b e } } \\cdot \\left( y ^ { \\mu } { \\bf x } ^ { \\mu } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "of each training example, where large (small) margins", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 104, + 255, + 405, + 270 + ], + "score": 1.0, + "content": "correspond to easy (hard) examples; (3) construct a pruned dataset of size", + "type": "text" + }, + { + "bbox": [ + 406, + 256, + 456, + 268 + ], + "score": 0.92, + "content": "P _ { \\mathrm { p r u n e } } = f P", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 255, + 487, + 270 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 487, + 257, + 495, + 268 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 255, + 506, + 270 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 291, + 281 + ], + "score": 1.0, + "content": "the fraction of examples kept, by retaining the", + "type": "text" + }, + { + "bbox": [ + 291, + 267, + 315, + 279 + ], + "score": 0.91, + "content": "P _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "hardest examples, (4) train a new perceptron to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 276, + 490, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 322, + 295 + ], + "score": 1.0, + "content": "completion on the smaller dataset with a smaller ratio", + "type": "text" + }, + { + "bbox": [ + 323, + 278, + 379, + 294 + ], + "score": 0.94, + "content": "\\begin{array} { r } { \\alpha _ { \\mathrm { p r u n e } } = \\frac { P _ { \\mathrm { p r u n e } } } { N } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 276, + 490, + 294 + ], + "score": 1.0, + "content": "of examples to parameters.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 297, + 505, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 297, + 504, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 245, + 309 + ], + "score": 1.0, + "content": "We are interested in the test error", + "type": "text" + }, + { + "bbox": [ + 245, + 299, + 252, + 307 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 297, + 416, + 309 + ], + "score": 1.0, + "content": "of this final perceptron as a function of", + "type": "text" + }, + { + "bbox": [ + 416, + 297, + 443, + 308 + ], + "score": 0.44, + "content": "\\alpha _ { \\mathrm { t o t } } , f", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 297, + 504, + 309 + ], + "score": 1.0, + "content": ", and the angle", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 107, + 308, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 107, + 308, + 113, + 318 + ], + "score": 0.72, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 308, + 223, + 321 + ], + "score": 1.0, + "content": "between the probe student", + "type": "text" + }, + { + "bbox": [ + 223, + 308, + 247, + 320 + ], + "score": 0.9, + "content": "\\mathbf { J _ { \\mathrm { { p r o b e } } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 308, + 313, + 321 + ], + "score": 1.0, + "content": "and the teacher", + "type": "text" + }, + { + "bbox": [ + 313, + 308, + 322, + 318 + ], + "score": 0.35, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 308, + 431, + 321 + ], + "score": 1.0, + "content": ". Our theory approximates", + "type": "text" + }, + { + "bbox": [ + 432, + 309, + 455, + 320 + ], + "score": 0.89, + "content": "\\mathbf { J _ { \\mathrm { { p r o b e } } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 308, + 506, + 321 + ], + "score": 1.0, + "content": "as simply a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 311, + 332 + ], + "score": 1.0, + "content": "random Gaussian vector conditioned to have angle", + "type": "text" + }, + { + "bbox": [ + 312, + 320, + 318, + 329 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 318, + 385, + 332 + ], + "score": 1.0, + "content": "with the teacher", + "type": "text" + }, + { + "bbox": [ + 386, + 320, + 395, + 329 + ], + "score": 0.38, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 318, + 506, + 332 + ], + "score": 1.0, + "content": ". Under this approximation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 233, + 343 + ], + "score": 1.0, + "content": "we obtain an analytic theory for", + "type": "text" + }, + { + "bbox": [ + 233, + 330, + 280, + 342 + ], + "score": 0.93, + "content": "\\varepsilon ( \\alpha _ { \\mathrm { t o t } } , f , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "that is asymptotically exact in the high dimensional limit", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 272, + 353 + ], + "score": 1.0, + "content": "(App. A). We first examine results when", + "type": "text" + }, + { + "bbox": [ + 273, + 341, + 298, + 351 + ], + "score": 0.9, + "content": "\\theta = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 340, + 505, + 353 + ], + "score": 1.0, + "content": ", so we are pruning training examples according to", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "their veridical margins with respect to the teacher (Fig. 1A). We find two striking phenomena, each", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 362, + 503, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 503, + 375 + ], + "score": 1.0, + "content": "of which constitute predictions in real-world settings that we will successfully confirm empirically.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 506, + 583 + ], + "lines": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "score": 1.0, + "content": "The best pruning strategy depends on the amount of initial data. First, we note the test error", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 396, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 147, + 410 + ], + "score": 1.0, + "content": "curve for", + "type": "text" + }, + { + "bbox": [ + 147, + 397, + 175, + 408 + ], + "score": 0.91, + "content": "f = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 396, + 506, + 410 + ], + "score": 1.0, + "content": "in Fig. 1A corresponding to no pruning, or equivalently to randomly pruning a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 406, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 190, + 421 + ], + "score": 1.0, + "content": "larger dataset of size", + "type": "text" + }, + { + "bbox": [ + 190, + 408, + 206, + 418 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 406, + 265, + 421 + ], + "score": 1.0, + "content": "down to a size", + "type": "text" + }, + { + "bbox": [ + 266, + 408, + 289, + 420 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 406, + 506, + 421 + ], + "score": 1.0, + "content": ", exhibits the well known classical perceptron learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 102, + 417, + 508, + 434 + ], + "spans": [ + { + "bbox": [ + 102, + 417, + 183, + 434 + ], + "score": 1.0, + "content": "power law scaling", + "type": "text" + }, + { + "bbox": [ + 184, + 419, + 227, + 433 + ], + "score": 0.92, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 417, + 361, + 434 + ], + "score": 1.0, + "content": ". Interestingly though, for small", + "type": "text" + }, + { + "bbox": [ + 362, + 420, + 377, + 430 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 417, + 508, + 434 + ], + "score": 1.0, + "content": ", keeping the hardest examples", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 429, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 433, + 444 + ], + "score": 1.0, + "content": "performs worse than random pruning (lighter curves above darkest curve for small", + "type": "text" + }, + { + "bbox": [ + 433, + 431, + 457, + 442 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 429, + 507, + 444 + ], + "score": 1.0, + "content": "in Fig. 1A).", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 441, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 186, + 454 + ], + "score": 1.0, + "content": "However, for large", + "type": "text" + }, + { + "bbox": [ + 186, + 442, + 202, + 452 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 441, + 506, + 454 + ], + "score": 1.0, + "content": ", keeping the hardest examples performs substantially better than random", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 327, + 466 + ], + "score": 1.0, + "content": "pruning (lighter curves below darkest curve for large", + "type": "text" + }, + { + "bbox": [ + 328, + 453, + 352, + 464 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "in Fig. 1A). It turns out keeping the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 387, + 476 + ], + "score": 1.0, + "content": "easiest rather than hardest examples is a better pruning strategy when", + "type": "text" + }, + { + "bbox": [ + 387, + 465, + 403, + 474 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "is small (Fig. 1C). If one", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "score": 1.0, + "content": "does not have much data to start with, it is better to keep the easiest examples with largest margins", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "(i.e. the blue regions of Fig. 1B) to avoid overfitting. The easiest examples provide coarse-grained", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "information about the target function, while the hard examples provide fine-grained information", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "about the target function which can prevent the model from learning if one starts with lots of data.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 518, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 506, + 529 + ], + "score": 1.0, + "content": "In cases where overfitting is less of an issue, it is best to keep the hardest examples with smallest", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "score": 1.0, + "content": "margin that provide more information about the teacher’s decision boundary (i.e. the green region of", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 538, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 506, + 552 + ], + "score": 1.0, + "content": "Fig. 1B). Intuitively, in the limited data regime, it is challenging to model outliers since the basics are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "not adequately captured; hence, it is more important to keep easy examples so that the model can get", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 561, + 506, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 506, + 574 + ], + "score": 1.0, + "content": "to moderate error. However, with a larger dataset, the easy examples can be learned without difficulty,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 572, + 321, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 321, + 585 + ], + "score": 1.0, + "content": "making modeling outliers the fundamental challenge.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 588, + 505, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 381, + 601 + ], + "score": 1.0, + "content": "Fig. 1C reveals which pruning strategy is best as a joint function of", + "type": "text" + }, + { + "bbox": [ + 381, + 590, + 397, + 600 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 588, + 415, + 601 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 588, + 423, + 600 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 588, + 505, + 601 + ], + "score": 1.0, + "content": ". Note the transition", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 351, + 612 + ], + "score": 1.0, + "content": "between optimal strategies becomes sharper at small fractions", + "type": "text" + }, + { + "bbox": [ + 351, + 600, + 358, + 611 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "of data kept. This transition between", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 611, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 622 + ], + "score": 1.0, + "content": "optimal pruning strategies can be viewed as a prediction in more general settings. To test this", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "prediction we trained a ResNet18 on pruned subsets of the CIFAR-10 dataset (Fig. 1D), and observed", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "score": 1.0, + "content": "strikingly similar behavior, indicating the prediction can hold far more generally, beyond perceptron", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 642, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 642, + 505, + 657 + ], + "score": 1.0, + "content": "learning. Interestingly, [9, 10] missed this transition, likely because they started pruning from large", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 653, + 144, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 144, + 666 + ], + "score": 1.0, + "content": "datasets.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 723 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "Pareto optimal data pruning can beat power law scaling. A second prediction of our theory", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 254, + 700 + ], + "score": 1.0, + "content": "is that when keeping a fixed fraction", + "type": "text" + }, + { + "bbox": [ + 255, + 688, + 262, + 699 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 688, + 371, + 700 + ], + "score": 1.0, + "content": "of the hardest examples as", + "type": "text" + }, + { + "bbox": [ + 372, + 689, + 387, + 699 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "increases (i.e. constant color", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 357, + 712 + ], + "score": 1.0, + "content": "curves in Fig. 1A), the error initially drops exponentially in", + "type": "text" + }, + { + "bbox": [ + 357, + 699, + 417, + 711 + ], + "score": 0.91, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ", but then settles into", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 103, + 707, + 506, + 728 + ], + "spans": [ + { + "bbox": [ + 103, + 707, + 207, + 728 + ], + "score": 1.0, + "content": "the universal power law", + "type": "text" + }, + { + "bbox": [ + 207, + 710, + 250, + 724 + ], + "score": 0.92, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 707, + 302, + 728 + ], + "score": 1.0, + "content": "for all fixed", + "type": "text" + }, + { + "bbox": [ + 302, + 711, + 309, + 722 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 707, + 506, + 728 + ], + "score": 1.0, + "content": ". Thus there is no asymptotic advantage to data", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 753 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 117 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 105, + 72, + 506, + 118 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 106, + 132, + 304, + 146 + ], + "lines": [ + { + "bbox": [ + 104, + 129, + 306, + 149 + ], + "spans": [ + { + "bbox": [ + 104, + 129, + 306, + 149 + ], + "score": 1.0, + "content": "3 An analytic theory of data pruning", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 156, + 506, + 293 + ], + "lines": [ + { + "bbox": [ + 104, + 155, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 104, + 155, + 506, + 169 + ], + "score": 1.0, + "content": "To better understand data pruning, we employed the replica method from statistical mechanics [34] to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 168, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 106, + 168, + 506, + 180 + ], + "score": 1.0, + "content": "develop an analytic theory of pruning for the perceptron in the student-teacher setting [25] (see App. A", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 175, + 503, + 193 + ], + "spans": [ + { + "bbox": [ + 104, + 175, + 382, + 193 + ], + "score": 1.0, + "content": "for detailed derivations of all results). Consider a training dataset of", + "type": "text" + }, + { + "bbox": [ + 382, + 179, + 391, + 188 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 175, + 433, + 193 + ], + "score": 1.0, + "content": "examples", + "type": "text" + }, + { + "bbox": [ + 433, + 178, + 503, + 191 + ], + "score": 0.91, + "content": "\\{ { \\bf x } ^ { \\mu } , y ^ { \\mu } \\} _ { \\mu = 1 , \\dots , P }", + "type": "inline_equation" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 133, + 204 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 190, + 173, + 201 + ], + "score": 0.92, + "content": "\\mathbf { x } ^ { \\mu } \\in \\mathbb { R } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 188, + 428, + 204 + ], + "score": 1.0, + "content": "are i.i.d. zero mean unit variance random Gaussian inputs and", + "type": "text" + }, + { + "bbox": [ + 429, + 191, + 505, + 202 + ], + "score": 0.89, + "content": "y ^ { \\mu } = \\operatorname { s i g n } ( \\mathbf { T } \\cdot \\mathbf { x } ^ { \\mu } )", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 199, + 507, + 215 + ], + "spans": [ + { + "bbox": [ + 104, + 199, + 372, + 215 + ], + "score": 1.0, + "content": "are labels generated by a teacher perceptron with weight vector", + "type": "text" + }, + { + "bbox": [ + 372, + 201, + 411, + 211 + ], + "score": 0.91, + "content": "\\mathbf { T } \\in \\mathbf { \\mathbb { R } } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 199, + 507, + 215 + ], + "score": 1.0, + "content": ". We work in the high", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 102, + 206, + 510, + 231 + ], + "spans": [ + { + "bbox": [ + 102, + 206, + 243, + 231 + ], + "score": 1.0, + "content": "dimensional statistics limit where", + "type": "text" + }, + { + "bbox": [ + 243, + 213, + 290, + 223 + ], + "score": 0.9, + "content": "N , P \\to \\infty", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 206, + 342, + 231 + ], + "score": 1.0, + "content": "but the ratio", + "type": "text" + }, + { + "bbox": [ + 343, + 212, + 380, + 225 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { \\mathrm { t o t } } = \\frac { P } { N } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 206, + 510, + 231 + ], + "score": 1.0, + "content": "of the number of total training", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 234, + 236 + ], + "score": 1.0, + "content": "examples to parameters remains", + "type": "text" + }, + { + "bbox": [ + 235, + 224, + 256, + 235 + ], + "score": 0.9, + "content": "O ( 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 223, + 506, + 236 + ], + "score": 1.0, + "content": ". We then consider a pruning algorithm used in [9, 10], namely:", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 232, + 507, + 248 + ], + "spans": [ + { + "bbox": [ + 104, + 232, + 478, + 248 + ], + "score": 1.0, + "content": "(1) train a probe student perceptron for very few epochs on the training data, obtaining weights", + "type": "text" + }, + { + "bbox": [ + 478, + 235, + 502, + 246 + ], + "score": 0.89, + "content": "\\mathbf { J _ { \\mathrm { p r o b e } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 232, + 507, + 248 + ], + "score": 1.0, + "content": ";", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 201, + 259 + ], + "score": 1.0, + "content": "(2) compute the margin", + "type": "text" + }, + { + "bbox": [ + 201, + 245, + 289, + 257 + ], + "score": 0.94, + "content": "m ^ { \\mu } = { \\bf J } _ { \\mathrm { p r o b e } } \\cdot \\left( y ^ { \\mu } { \\bf x } ^ { \\mu } \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "of each training example, where large (small) margins", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 104, + 255, + 405, + 270 + ], + "score": 1.0, + "content": "correspond to easy (hard) examples; (3) construct a pruned dataset of size", + "type": "text" + }, + { + "bbox": [ + 406, + 256, + 456, + 268 + ], + "score": 0.92, + "content": "P _ { \\mathrm { p r u n e } } = f P", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 255, + 487, + 270 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 487, + 257, + 495, + 268 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 255, + 506, + 270 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 291, + 281 + ], + "score": 1.0, + "content": "the fraction of examples kept, by retaining the", + "type": "text" + }, + { + "bbox": [ + 291, + 267, + 315, + 279 + ], + "score": 0.91, + "content": "P _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "hardest examples, (4) train a new perceptron to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 276, + 490, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 322, + 295 + ], + "score": 1.0, + "content": "completion on the smaller dataset with a smaller ratio", + "type": "text" + }, + { + "bbox": [ + 323, + 278, + 379, + 294 + ], + "score": 0.94, + "content": "\\begin{array} { r } { \\alpha _ { \\mathrm { p r u n e } } = \\frac { P _ { \\mathrm { p r u n e } } } { N } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 276, + 490, + 294 + ], + "score": 1.0, + "content": "of examples to parameters.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 10.5, + "bbox_fs": [ + 102, + 155, + 510, + 295 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 297, + 505, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 297, + 504, + 309 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 245, + 309 + ], + "score": 1.0, + "content": "We are interested in the test error", + "type": "text" + }, + { + "bbox": [ + 245, + 299, + 252, + 307 + ], + "score": 0.74, + "content": "\\varepsilon", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 297, + 416, + 309 + ], + "score": 1.0, + "content": "of this final perceptron as a function of", + "type": "text" + }, + { + "bbox": [ + 416, + 297, + 443, + 308 + ], + "score": 0.44, + "content": "\\alpha _ { \\mathrm { t o t } } , f", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 297, + 504, + 309 + ], + "score": 1.0, + "content": ", and the angle", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 107, + 308, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 107, + 308, + 113, + 318 + ], + "score": 0.72, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 308, + 223, + 321 + ], + "score": 1.0, + "content": "between the probe student", + "type": "text" + }, + { + "bbox": [ + 223, + 308, + 247, + 320 + ], + "score": 0.9, + "content": "\\mathbf { J _ { \\mathrm { { p r o b e } } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 308, + 313, + 321 + ], + "score": 1.0, + "content": "and the teacher", + "type": "text" + }, + { + "bbox": [ + 313, + 308, + 322, + 318 + ], + "score": 0.35, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 308, + 431, + 321 + ], + "score": 1.0, + "content": ". Our theory approximates", + "type": "text" + }, + { + "bbox": [ + 432, + 309, + 455, + 320 + ], + "score": 0.89, + "content": "\\mathbf { J _ { \\mathrm { { p r o b e } } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 308, + 506, + 321 + ], + "score": 1.0, + "content": "as simply a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 318, + 506, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 311, + 332 + ], + "score": 1.0, + "content": "random Gaussian vector conditioned to have angle", + "type": "text" + }, + { + "bbox": [ + 312, + 320, + 318, + 329 + ], + "score": 0.78, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 318, + 318, + 385, + 332 + ], + "score": 1.0, + "content": "with the teacher", + "type": "text" + }, + { + "bbox": [ + 386, + 320, + 395, + 329 + ], + "score": 0.38, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 318, + 506, + 332 + ], + "score": 1.0, + "content": ". Under this approximation", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 233, + 343 + ], + "score": 1.0, + "content": "we obtain an analytic theory for", + "type": "text" + }, + { + "bbox": [ + 233, + 330, + 280, + 342 + ], + "score": 0.93, + "content": "\\varepsilon ( \\alpha _ { \\mathrm { t o t } } , f , \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "that is asymptotically exact in the high dimensional limit", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 272, + 353 + ], + "score": 1.0, + "content": "(App. A). We first examine results when", + "type": "text" + }, + { + "bbox": [ + 273, + 341, + 298, + 351 + ], + "score": 0.9, + "content": "\\theta = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 340, + 505, + 353 + ], + "score": 1.0, + "content": ", so we are pruning training examples according to", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "their veridical margins with respect to the teacher (Fig. 1A). We find two striking phenomena, each", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 362, + 503, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 503, + 375 + ], + "score": 1.0, + "content": "of which constitute predictions in real-world settings that we will successfully confirm empirically.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 297, + 506, + 375 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 506, + 583 + ], + "lines": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 398 + ], + "score": 1.0, + "content": "The best pruning strategy depends on the amount of initial data. First, we note the test error", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 396, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 147, + 410 + ], + "score": 1.0, + "content": "curve for", + "type": "text" + }, + { + "bbox": [ + 147, + 397, + 175, + 408 + ], + "score": 0.91, + "content": "f = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 396, + 506, + 410 + ], + "score": 1.0, + "content": "in Fig. 1A corresponding to no pruning, or equivalently to randomly pruning a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 406, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 190, + 421 + ], + "score": 1.0, + "content": "larger dataset of size", + "type": "text" + }, + { + "bbox": [ + 190, + 408, + 206, + 418 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 406, + 265, + 421 + ], + "score": 1.0, + "content": "down to a size", + "type": "text" + }, + { + "bbox": [ + 266, + 408, + 289, + 420 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 406, + 506, + 421 + ], + "score": 1.0, + "content": ", exhibits the well known classical perceptron learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 102, + 417, + 508, + 434 + ], + "spans": [ + { + "bbox": [ + 102, + 417, + 183, + 434 + ], + "score": 1.0, + "content": "power law scaling", + "type": "text" + }, + { + "bbox": [ + 184, + 419, + 227, + 433 + ], + "score": 0.92, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 417, + 361, + 434 + ], + "score": 1.0, + "content": ". Interestingly though, for small", + "type": "text" + }, + { + "bbox": [ + 362, + 420, + 377, + 430 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 417, + 508, + 434 + ], + "score": 1.0, + "content": ", keeping the hardest examples", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 429, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 433, + 444 + ], + "score": 1.0, + "content": "performs worse than random pruning (lighter curves above darkest curve for small", + "type": "text" + }, + { + "bbox": [ + 433, + 431, + 457, + 442 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 429, + 507, + 444 + ], + "score": 1.0, + "content": "in Fig. 1A).", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 441, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 186, + 454 + ], + "score": 1.0, + "content": "However, for large", + "type": "text" + }, + { + "bbox": [ + 186, + 442, + 202, + 452 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 441, + 506, + 454 + ], + "score": 1.0, + "content": ", keeping the hardest examples performs substantially better than random", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 327, + 466 + ], + "score": 1.0, + "content": "pruning (lighter curves below darkest curve for large", + "type": "text" + }, + { + "bbox": [ + 328, + 453, + 352, + 464 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 353, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "in Fig. 1A). It turns out keeping the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 387, + 476 + ], + "score": 1.0, + "content": "easiest rather than hardest examples is a better pruning strategy when", + "type": "text" + }, + { + "bbox": [ + 387, + 465, + 403, + 474 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "is small (Fig. 1C). If one", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "score": 1.0, + "content": "does not have much data to start with, it is better to keep the easiest examples with largest margins", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "(i.e. the blue regions of Fig. 1B) to avoid overfitting. The easiest examples provide coarse-grained", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 508 + ], + "score": 1.0, + "content": "information about the target function, while the hard examples provide fine-grained information", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 506, + 519 + ], + "score": 1.0, + "content": "about the target function which can prevent the model from learning if one starts with lots of data.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 518, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 506, + 529 + ], + "score": 1.0, + "content": "In cases where overfitting is less of an issue, it is best to keep the hardest examples with smallest", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "score": 1.0, + "content": "margin that provide more information about the teacher’s decision boundary (i.e. the green region of", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 538, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 104, + 538, + 506, + 552 + ], + "score": 1.0, + "content": "Fig. 1B). Intuitively, in the limited data regime, it is challenging to model outliers since the basics are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "not adequately captured; hence, it is more important to keep easy examples so that the model can get", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 561, + 506, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 506, + 574 + ], + "score": 1.0, + "content": "to moderate error. However, with a larger dataset, the easy examples can be learned without difficulty,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 572, + 321, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 321, + 585 + ], + "score": 1.0, + "content": "making modeling outliers the fundamental challenge.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 32.5, + "bbox_fs": [ + 102, + 385, + 508, + 585 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 588, + 505, + 665 + ], + "lines": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 381, + 601 + ], + "score": 1.0, + "content": "Fig. 1C reveals which pruning strategy is best as a joint function of", + "type": "text" + }, + { + "bbox": [ + 381, + 590, + 397, + 600 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 588, + 415, + 601 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 588, + 423, + 600 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 588, + 505, + 601 + ], + "score": 1.0, + "content": ". Note the transition", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 351, + 612 + ], + "score": 1.0, + "content": "between optimal strategies becomes sharper at small fractions", + "type": "text" + }, + { + "bbox": [ + 351, + 600, + 358, + 611 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "of data kept. This transition between", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 611, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 622 + ], + "score": 1.0, + "content": "optimal pruning strategies can be viewed as a prediction in more general settings. To test this", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "prediction we trained a ResNet18 on pruned subsets of the CIFAR-10 dataset (Fig. 1D), and observed", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 505, + 645 + ], + "score": 1.0, + "content": "strikingly similar behavior, indicating the prediction can hold far more generally, beyond perceptron", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 642, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 642, + 505, + 657 + ], + "score": 1.0, + "content": "learning. Interestingly, [9, 10] missed this transition, likely because they started pruning from large", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 653, + 144, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 144, + 666 + ], + "score": 1.0, + "content": "datasets.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 45, + "bbox_fs": [ + 104, + 588, + 505, + 666 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 723 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 690 + ], + "score": 1.0, + "content": "Pareto optimal data pruning can beat power law scaling. A second prediction of our theory", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 254, + 700 + ], + "score": 1.0, + "content": "is that when keeping a fixed fraction", + "type": "text" + }, + { + "bbox": [ + 255, + 688, + 262, + 699 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 688, + 371, + 700 + ], + "score": 1.0, + "content": "of the hardest examples as", + "type": "text" + }, + { + "bbox": [ + 372, + 689, + 387, + 699 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "increases (i.e. constant color", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 357, + 712 + ], + "score": 1.0, + "content": "curves in Fig. 1A), the error initially drops exponentially in", + "type": "text" + }, + { + "bbox": [ + 357, + 699, + 417, + 711 + ], + "score": 0.91, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 698, + 506, + 712 + ], + "score": 1.0, + "content": ", but then settles into", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 103, + 707, + 506, + 728 + ], + "spans": [ + { + "bbox": [ + 103, + 707, + 207, + 728 + ], + "score": 1.0, + "content": "the universal power law", + "type": "text" + }, + { + "bbox": [ + 207, + 710, + 250, + 724 + ], + "score": 0.92, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 707, + 302, + 728 + ], + "score": 1.0, + "content": "for all fixed", + "type": "text" + }, + { + "bbox": [ + 302, + 711, + 309, + 722 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 707, + 506, + 728 + ], + "score": 1.0, + "content": ". Thus there is no asymptotic advantage to data", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 177, + 256 + ], + "score": 1.0, + "content": "pruning at a fixed", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 177, + 244, + 184, + 255 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 185, + 243, + 380, + 256 + ], + "score": 1.0, + "content": ". However, by pruning more aggressively (smaller", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 380, + 244, + 388, + 255 + ], + "score": 0.7, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 388, + 243, + 506, + 256 + ], + "score": 1.0, + "content": ") when given more initial data", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 134, + 268 + ], + "score": 1.0, + "content": "(larger", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 134, + 255, + 151, + 266 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t . } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 151, + 254, + 462, + 268 + ], + "score": 1.0, + "content": "), one can achieve a Pareto optimal test error as a function of pruned dataset size", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 463, + 255, + 487, + 266 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 487, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "that", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 279 + ], + "score": 1.0, + "content": "remarkably traces out at least an exponential scaling law (Fig. 1A, purple curve). Indeed our theory", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 275, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 176, + 290 + ], + "score": 1.0, + "content": "predicts for each", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 176, + 277, + 200, + 288 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 200, + 275, + 303, + 290 + ], + "score": 1.0, + "content": "a Pareto optimal point in", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 303, + 277, + 319, + 287 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 320, + 275, + 337, + 290 + ], + "score": 1.0, + "content": "and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 338, + 276, + 345, + 287 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 345, + 275, + 390, + 290 + ], + "score": 1.0, + "content": "(subject to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 391, + 276, + 451, + 288 + ], + "score": 0.92, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 452, + 275, + 506, + 290 + ], + "score": 1.0, + "content": ", yielding for", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 286, + 506, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 152, + 301 + ], + "score": 1.0, + "content": "every fixed", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 153, + 289, + 177, + 299 + ], + "score": 0.89, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 177, + 286, + 222, + 301 + ], + "score": 1.0, + "content": "an optimal", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 223, + 287, + 238, + 299 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 238, + 286, + 338, + 301 + ], + "score": 1.0, + "content": ", plotted in Fig. 1E. Note", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 338, + 288, + 353, + 299 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 354, + 286, + 415, + 301 + ], + "score": 1.0, + "content": "decreases with", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 415, + 289, + 439, + 299 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 439, + 286, + 506, + 301 + ], + "score": 1.0, + "content": "indicating more", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 222, + 311 + ], + "score": 1.0, + "content": "aggressive pruning (smaller", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 222, + 299, + 239, + 310 + ], + "score": 0.86, + "content": "f _ { \\mathrm { o p t } } )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 239, + 298, + 378, + 311 + ], + "score": 1.0, + "content": ") of original datasets of larger size", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 378, + 299, + 394, + 309 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 394, + 298, + 505, + 311 + ], + "score": 1.0, + "content": "is required to obtain larger", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 502, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 260, + 323 + ], + "score": 1.0, + "content": "Pareto optimal pruned datasets of size", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 260, + 309, + 284, + 321 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 284, + 308, + 502, + 323 + ], + "score": 1.0, + "content": ". We will test this striking scaling prediction in Fig. 3.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + } + ], + "index": 50.5, + "bbox_fs": [ + 103, + 676, + 506, + 728 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 129, + 72, + 482, + 181 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 72, + 482, + 181 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 72, + 482, + 181 + ], + "spans": [ + { + "bbox": [ + 129, + 72, + 482, + 181 + ], + "score": 0.973, + "type": "image", + "image_path": "57a2549d134949b92c470a9c19a0c10bb40524dc376bec35d42755f606757537.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 129, + 72, + 482, + 108.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 108.33333333333334, + 482, + 144.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 144.66666666666669, + 482, + 181.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 189, + 506, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 189, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 202 + ], + "score": 1.0, + "content": "Figure 2: Data pruning with an imperfect metric. A: Weight vectors and decision boundaries for a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 200, + 507, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 340, + 213 + ], + "score": 1.0, + "content": "teacher (black) and probe student (red) separated by angle", + "type": "text" + }, + { + "bbox": [ + 340, + 201, + 347, + 210 + ], + "score": 0.65, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 200, + 462, + 213 + ], + "score": 1.0, + "content": ". The black point has margin", + "type": "text" + }, + { + "bbox": [ + 462, + 201, + 483, + 212 + ], + "score": 0.58, + "content": "0 \\left( \\kappa \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 200, + 507, + 213 + ], + "score": 1.0, + "content": "w.r.t.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 210, + 465, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 317, + 224 + ], + "score": 1.0, + "content": "the probe (teacher). B–D: Test error as a function of", + "type": "text" + }, + { + "bbox": [ + 317, + 212, + 341, + 223 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 210, + 393, + 224 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 393, + 212, + 400, + 222 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 210, + 455, + 224 + ], + "score": 1.0, + "content": "and different", + "type": "text" + }, + { + "bbox": [ + 455, + 212, + 461, + 221 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 210, + 465, + 224 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 243, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 177, + 256 + ], + "score": 1.0, + "content": "pruning at a fixed", + "type": "text" + }, + { + "bbox": [ + 177, + 244, + 184, + 255 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 243, + 380, + 256 + ], + "score": 1.0, + "content": ". However, by pruning more aggressively (smaller", + "type": "text" + }, + { + "bbox": [ + 380, + 244, + 388, + 255 + ], + "score": 0.7, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 243, + 506, + 256 + ], + "score": 1.0, + "content": ") when given more initial data", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 254, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 134, + 268 + ], + "score": 1.0, + "content": "(larger", + "type": "text" + }, + { + "bbox": [ + 134, + 255, + 151, + 266 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t . } }", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 254, + 462, + 268 + ], + "score": 1.0, + "content": "), one can achieve a Pareto optimal test error as a function of pruned dataset size", + "type": "text" + }, + { + "bbox": [ + 463, + 255, + 487, + 266 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 254, + 506, + 268 + ], + "score": 1.0, + "content": "that", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 264, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 279 + ], + "score": 1.0, + "content": "remarkably traces out at least an exponential scaling law (Fig. 1A, purple curve). Indeed our theory", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 275, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 176, + 290 + ], + "score": 1.0, + "content": "predicts for each", + "type": "text" + }, + { + "bbox": [ + 176, + 277, + 200, + 288 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 275, + 303, + 290 + ], + "score": 1.0, + "content": "a Pareto optimal point in", + "type": "text" + }, + { + "bbox": [ + 303, + 277, + 319, + 287 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 275, + 337, + 290 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 338, + 276, + 345, + 287 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 275, + 390, + 290 + ], + "score": 1.0, + "content": "(subject to", + "type": "text" + }, + { + "bbox": [ + 391, + 276, + 451, + 288 + ], + "score": 0.92, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 275, + 506, + 290 + ], + "score": 1.0, + "content": ", yielding for", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 286, + 506, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 152, + 301 + ], + "score": 1.0, + "content": "every fixed", + "type": "text" + }, + { + "bbox": [ + 153, + 289, + 177, + 299 + ], + "score": 0.89, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 286, + 222, + 301 + ], + "score": 1.0, + "content": "an optimal", + "type": "text" + }, + { + "bbox": [ + 223, + 287, + 238, + 299 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 286, + 338, + 301 + ], + "score": 1.0, + "content": ", plotted in Fig. 1E. Note", + "type": "text" + }, + { + "bbox": [ + 338, + 288, + 353, + 299 + ], + "score": 0.89, + "content": "f _ { \\mathrm { o p t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 286, + 415, + 301 + ], + "score": 1.0, + "content": "decreases with", + "type": "text" + }, + { + "bbox": [ + 415, + 289, + 439, + 299 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 286, + 506, + 301 + ], + "score": 1.0, + "content": "indicating more", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 222, + 311 + ], + "score": 1.0, + "content": "aggressive pruning (smaller", + "type": "text" + }, + { + "bbox": [ + 222, + 299, + 239, + 310 + ], + "score": 0.86, + "content": "f _ { \\mathrm { o p t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 298, + 378, + 311 + ], + "score": 1.0, + "content": ") of original datasets of larger size", + "type": "text" + }, + { + "bbox": [ + 378, + 299, + 394, + 309 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 394, + 298, + 505, + 311 + ], + "score": 1.0, + "content": "is required to obtain larger", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 502, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 260, + 323 + ], + "score": 1.0, + "content": "Pareto optimal pruned datasets of size", + "type": "text" + }, + { + "bbox": [ + 260, + 309, + 284, + 321 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 308, + 502, + 323 + ], + "score": 1.0, + "content": ". We will test this striking scaling prediction in Fig. 3.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "score": 1.0, + "content": "Beating power law scaling: an information-theoretic perspective. Classical randomly selected", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "data generates slow power law error scaling because each extra training example provides less new", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 352, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 475, + 367 + ], + "score": 1.0, + "content": "information about the correct decision boundary than the previous example. More formally, let", + "type": "text" + }, + { + "bbox": [ + 475, + 353, + 505, + 365 + ], + "score": 0.92, + "content": "S { \\left( \\alpha _ { \\mathrm { t o t } } \\right) }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "denote the typical entropy of the posterior distribution over student perceptron weights consistent", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 373, + 504, + 390 + ], + "spans": [ + { + "bbox": [ + 104, + 373, + 209, + 390 + ], + "score": 1.0, + "content": "with a training set of size", + "type": "text" + }, + { + "bbox": [ + 209, + 376, + 225, + 387 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 373, + 317, + 390 + ], + "score": 1.0, + "content": ". The information gain", + "type": "text" + }, + { + "bbox": [ + 317, + 375, + 345, + 387 + ], + "score": 0.92, + "content": "I ( \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 373, + 488, + 390 + ], + "score": 1.0, + "content": "due to additional examples beyond", + "type": "text" + }, + { + "bbox": [ + 488, + 376, + 504, + 387 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 385, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 104, + 385, + 390, + 403 + ], + "score": 1.0, + "content": "can be defined as the rate at which the posterior entropy is reduced:", + "type": "text" + }, + { + "bbox": [ + 391, + 386, + 488, + 402 + ], + "score": 0.93, + "content": "\\begin{array} { r } { I ( \\alpha _ { \\mathrm { t o t } } ) = - \\frac { d } { d \\alpha _ { \\mathrm { t o t } } } S ( \\alpha _ { \\mathrm { t o t } } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 385, + 506, + 403 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 226, + 414 + ], + "score": 1.0, + "content": "classical perceptron learning", + "type": "text" + }, + { + "bbox": [ + 227, + 400, + 255, + 412 + ], + "score": 0.92, + "content": "I ( \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 399, + 394, + 414 + ], + "score": 1.0, + "content": "decays to zero as a power law in", + "type": "text" + }, + { + "bbox": [ + 394, + 402, + 410, + 411 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 399, + 506, + 414 + ], + "score": 1.0, + "content": ", reflecting a vanishing", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "amount of information per each new example, leading to the slow power law decay of test error", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 422, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 142, + 435 + ], + "score": 0.91, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { t o t } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 423, + 506, + 438 + ], + "score": 1.0, + "content": ". However, data pruning can increase the information gained per example by pruning away", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 433, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 506, + 448 + ], + "score": 1.0, + "content": "the uninformative examples. To show this, we generalized the replica calculation of the posterior", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 443, + 504, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 443, + 139, + 460 + ], + "score": 1.0, + "content": "entropy", + "type": "text" + }, + { + "bbox": [ + 140, + 446, + 147, + 455 + ], + "score": 0.79, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 443, + 234, + 460 + ], + "score": 1.0, + "content": "and information gain", + "type": "text" + }, + { + "bbox": [ + 235, + 446, + 241, + 455 + ], + "score": 0.67, + "content": "I", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 443, + 359, + 460 + ], + "score": 1.0, + "content": "from random datasets of size", + "type": "text" + }, + { + "bbox": [ + 360, + 447, + 375, + 456 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 443, + 479, + 460 + ], + "score": 1.0, + "content": "to pruned datasets of size", + "type": "text" + }, + { + "bbox": [ + 480, + 447, + 504, + 457 + ], + "score": 0.81, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 306, + 470 + ], + "score": 1.0, + "content": "(App. A). We plot the resulting information gain", + "type": "text" + }, + { + "bbox": [ + 306, + 456, + 343, + 468 + ], + "score": 0.93, + "content": "I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 455, + 396, + 470 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 396, + 456, + 403, + 468 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 455, + 506, + 470 + ], + "score": 1.0, + "content": "in Fig. 1F. For any fixed", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 466, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 114, + 480 + ], + "score": 0.36, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 468, + 154, + 480 + ], + "score": 0.9, + "content": "\\dot { \\mathbf { \\rho } } , I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 466, + 315, + 484 + ], + "score": 1.0, + "content": "will eventually decay as a power law as", + "type": "text" + }, + { + "bbox": [ + 315, + 468, + 339, + 481 + ], + "score": 0.9, + "content": "\\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 466, + 506, + 484 + ], + "score": 1.0, + "content": ". However, by more aggressively pruning", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 140, + 494 + ], + "score": 1.0, + "content": "(smaller", + "type": "text" + }, + { + "bbox": [ + 141, + 482, + 148, + 492 + ], + "score": 0.78, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 480, + 237, + 494 + ], + "score": 1.0, + "content": ") datasets of larger size", + "type": "text" + }, + { + "bbox": [ + 238, + 481, + 253, + 492 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 480, + 257, + 494 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 257, + 480, + 294, + 493 + ], + "score": 0.89, + "content": "I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 480, + 410, + 494 + ], + "score": 1.0, + "content": "can converge to a finite value", + "type": "text" + }, + { + "bbox": [ + 411, + 480, + 453, + 492 + ], + "score": 0.92, + "content": "I ( \\infty ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "nat/example,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 492, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 504 + ], + "score": 1.0, + "content": "resulting in larger pruned datasets only adding useful non-redundant information. Since each new", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "example under Pareto optimal data pruning conveys finite information about the target decision", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 513, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 506, + 527 + ], + "score": 1.0, + "content": "boundary, as seen in Fig. 1F, the test error can decay at least exponentially in pruned dataset size", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "score": 1.0, + "content": "as in Fig. 1A. Classical results [30] have shown that training examples chosen by maximizing the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "disagreement of a committee of student perceptrons can provide an asymptotically finite information", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 545, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 104, + 545, + 505, + 560 + ], + "score": 1.0, + "content": "rate, leading to exponential decay in test error. Intriguingly, the Pareto-optimal data pruning strategy", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "we study in this work leads to faster than exponential decay, because it includes (partial) information", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 568, + 369, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 369, + 581 + ], + "score": 1.0, + "content": "about the target function provided by the probe student (Fig. 11).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 591, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "An imperfect pruning metric yields a cross over from exponential to power law scaling. We", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 104, + 601, + 267, + 614 + ], + "score": 1.0, + "content": "next examine the case of nonzero angle", + "type": "text" + }, + { + "bbox": [ + 267, + 602, + 274, + 612 + ], + "score": 0.77, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 601, + 382, + 614 + ], + "score": 1.0, + "content": "between the probe student", + "type": "text" + }, + { + "bbox": [ + 383, + 602, + 406, + 614 + ], + "score": 0.9, + "content": "\\mathbf { J _ { \\mathrm { p r o b e } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 601, + 471, + 614 + ], + "score": 1.0, + "content": "and the teacher", + "type": "text" + }, + { + "bbox": [ + 471, + 602, + 480, + 612 + ], + "score": 0.5, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 601, + 506, + 614 + ], + "score": 1.0, + "content": ", such", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 611, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 506, + 626 + ], + "score": 1.0, + "content": "that the ranking of training examples by margin is no longer completely accurate (Fig. 2A). Retaining", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "the hard examples with smallest margin with respect to the probe student will always result in pruned", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 331, + 647 + ], + "score": 1.0, + "content": "datasets lying near the probe’s decision boundary. But if", + "type": "text" + }, + { + "bbox": [ + 331, + 635, + 338, + 644 + ], + "score": 0.82, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "is large, such examples might be far from", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "the teacher’s decision boundary, and therefore could be less informative about the teacher (Fig. 2A).", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 451, + 668 + ], + "score": 1.0, + "content": "As a result our theory, confirmed by simulations, predicts that under nonzero angles", + "type": "text" + }, + { + "bbox": [ + 451, + 657, + 457, + 666 + ], + "score": 0.7, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 655, + 505, + 668 + ], + "score": 1.0, + "content": ", the Pareto", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 292, + 680 + ], + "score": 1.0, + "content": "optimal lower envelope of test error over both", + "type": "text" + }, + { + "bbox": [ + 293, + 668, + 308, + 678 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 667, + 326, + 680 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 326, + 667, + 333, + 679 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "initially scales exponentially as a function", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 117, + 691 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 678, + 175, + 690 + ], + "score": 0.93, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 678, + 496, + 691 + ], + "score": 1.0, + "content": "but then crosses over to a power law (Fig. 2BCD). Indeed, at any given nonzero", + "type": "text" + }, + { + "bbox": [ + 496, + 678, + 502, + 688 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 678, + 506, + 691 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 104, + 688, + 207, + 703 + ], + "score": 1.0, + "content": "our theory reveals that as", + "type": "text" + }, + { + "bbox": [ + 207, + 690, + 223, + 700 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 688, + 281, + 703 + ], + "score": 1.0, + "content": "(and therefore", + "type": "text" + }, + { + "bbox": [ + 281, + 690, + 305, + 701 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { p r u n e . } }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 688, + 506, + 703 + ], + "score": 1.0, + "content": ") becomes large, one cannot decrease test error any", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 310, + 713 + ], + "score": 1.0, + "content": "further by retaining less than a minimum fraction", + "type": "text" + }, + { + "bbox": [ + 310, + 700, + 340, + 712 + ], + "score": 0.92, + "content": "f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "of all available data. For example when", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 107, + 711, + 182, + 722 + ], + "score": 0.28, + "content": "\\theta = 1 0 ^ { \\circ } \\overset { \\cdot } { ( } \\theta = 2 0 ^ { \\circ } )", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 709, + 412, + 723 + ], + "score": 1.0, + "content": "one can do no better asymptotically than pruning down to", + "type": "text" + }, + { + "bbox": [ + 412, + 711, + 432, + 721 + ], + "score": 0.83, + "content": "24 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 711, + 457, + 722 + ], + "score": 0.76, + "content": "( 4 6 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "of the total", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 40.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 129, + 72, + 482, + 181 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 129, + 72, + 482, + 181 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 129, + 72, + 482, + 181 + ], + "spans": [ + { + "bbox": [ + 129, + 72, + 482, + 181 + ], + "score": 0.973, + "type": "image", + "image_path": "57a2549d134949b92c470a9c19a0c10bb40524dc376bec35d42755f606757537.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 129, + 72, + 482, + 108.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 129, + 108.33333333333334, + 482, + 144.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 129, + 144.66666666666669, + 482, + 181.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 189, + 506, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 189, + 506, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 202 + ], + "score": 1.0, + "content": "Figure 2: Data pruning with an imperfect metric. A: Weight vectors and decision boundaries for a", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 200, + 507, + 213 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 340, + 213 + ], + "score": 1.0, + "content": "teacher (black) and probe student (red) separated by angle", + "type": "text" + }, + { + "bbox": [ + 340, + 201, + 347, + 210 + ], + "score": 0.65, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 200, + 462, + 213 + ], + "score": 1.0, + "content": ". The black point has margin", + "type": "text" + }, + { + "bbox": [ + 462, + 201, + 483, + 212 + ], + "score": 0.58, + "content": "0 \\left( \\kappa \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 200, + 507, + 213 + ], + "score": 1.0, + "content": "w.r.t.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 210, + 465, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 317, + 224 + ], + "score": 1.0, + "content": "the probe (teacher). B–D: Test error as a function of", + "type": "text" + }, + { + "bbox": [ + 317, + 212, + 341, + 223 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 342, + 210, + 393, + 224 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 393, + 212, + 400, + 222 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 210, + 455, + 224 + ], + "score": 1.0, + "content": "and different", + "type": "text" + }, + { + "bbox": [ + 455, + 212, + 461, + 221 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 210, + 465, + 224 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 243, + 505, + 320 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 105, + 243, + 506, + 323 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "score": 1.0, + "content": "Beating power law scaling: an information-theoretic perspective. Classical randomly selected", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "data generates slow power law error scaling because each extra training example provides less new", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 352, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 475, + 367 + ], + "score": 1.0, + "content": "information about the correct decision boundary than the previous example. More formally, let", + "type": "text" + }, + { + "bbox": [ + 475, + 353, + 505, + 365 + ], + "score": 0.92, + "content": "S { \\left( \\alpha _ { \\mathrm { t o t } } \\right) }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "denote the typical entropy of the posterior distribution over student perceptron weights consistent", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 373, + 504, + 390 + ], + "spans": [ + { + "bbox": [ + 104, + 373, + 209, + 390 + ], + "score": 1.0, + "content": "with a training set of size", + "type": "text" + }, + { + "bbox": [ + 209, + 376, + 225, + 387 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 373, + 317, + 390 + ], + "score": 1.0, + "content": ". The information gain", + "type": "text" + }, + { + "bbox": [ + 317, + 375, + 345, + 387 + ], + "score": 0.92, + "content": "I ( \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 373, + 488, + 390 + ], + "score": 1.0, + "content": "due to additional examples beyond", + "type": "text" + }, + { + "bbox": [ + 488, + 376, + 504, + 387 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 385, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 104, + 385, + 390, + 403 + ], + "score": 1.0, + "content": "can be defined as the rate at which the posterior entropy is reduced:", + "type": "text" + }, + { + "bbox": [ + 391, + 386, + 488, + 402 + ], + "score": 0.93, + "content": "\\begin{array} { r } { I ( \\alpha _ { \\mathrm { t o t } } ) = - \\frac { d } { d \\alpha _ { \\mathrm { t o t } } } S ( \\alpha _ { \\mathrm { t o t } } ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 385, + 506, + 403 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 399, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 226, + 414 + ], + "score": 1.0, + "content": "classical perceptron learning", + "type": "text" + }, + { + "bbox": [ + 227, + 400, + 255, + 412 + ], + "score": 0.92, + "content": "I ( \\alpha _ { \\mathrm { t o t } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 399, + 394, + 414 + ], + "score": 1.0, + "content": "decays to zero as a power law in", + "type": "text" + }, + { + "bbox": [ + 394, + 402, + 410, + 411 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 399, + 506, + 414 + ], + "score": 1.0, + "content": ", reflecting a vanishing", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "amount of information per each new example, leading to the slow power law decay of test error", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 422, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 142, + 435 + ], + "score": 0.91, + "content": "\\varepsilon \\propto \\alpha _ { \\mathrm { t o t } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 423, + 506, + 438 + ], + "score": 1.0, + "content": ". However, data pruning can increase the information gained per example by pruning away", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 433, + 506, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 506, + 448 + ], + "score": 1.0, + "content": "the uninformative examples. To show this, we generalized the replica calculation of the posterior", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 443, + 504, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 443, + 139, + 460 + ], + "score": 1.0, + "content": "entropy", + "type": "text" + }, + { + "bbox": [ + 140, + 446, + 147, + 455 + ], + "score": 0.79, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 443, + 234, + 460 + ], + "score": 1.0, + "content": "and information gain", + "type": "text" + }, + { + "bbox": [ + 235, + 446, + 241, + 455 + ], + "score": 0.67, + "content": "I", + "type": "inline_equation" + }, + { + "bbox": [ + 241, + 443, + 359, + 460 + ], + "score": 1.0, + "content": "from random datasets of size", + "type": "text" + }, + { + "bbox": [ + 360, + 447, + 375, + 456 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 443, + 479, + 460 + ], + "score": 1.0, + "content": "to pruned datasets of size", + "type": "text" + }, + { + "bbox": [ + 480, + 447, + 504, + 457 + ], + "score": 0.81, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 455, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 306, + 470 + ], + "score": 1.0, + "content": "(App. A). We plot the resulting information gain", + "type": "text" + }, + { + "bbox": [ + 306, + 456, + 343, + 468 + ], + "score": 0.93, + "content": "I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 455, + 396, + 470 + ], + "score": 1.0, + "content": "for different", + "type": "text" + }, + { + "bbox": [ + 396, + 456, + 403, + 468 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 455, + 506, + 470 + ], + "score": 1.0, + "content": "in Fig. 1F. For any fixed", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 466, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 114, + 480 + ], + "score": 0.36, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 468, + 154, + 480 + ], + "score": 0.9, + "content": "\\dot { \\mathbf { \\rho } } , I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 466, + 315, + 484 + ], + "score": 1.0, + "content": "will eventually decay as a power law as", + "type": "text" + }, + { + "bbox": [ + 315, + 468, + 339, + 481 + ], + "score": 0.9, + "content": "\\alpha _ { \\mathrm { p r u n e } } ^ { - 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 466, + 506, + 484 + ], + "score": 1.0, + "content": ". However, by more aggressively pruning", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 480, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 140, + 494 + ], + "score": 1.0, + "content": "(smaller", + "type": "text" + }, + { + "bbox": [ + 141, + 482, + 148, + 492 + ], + "score": 0.78, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 480, + 237, + 494 + ], + "score": 1.0, + "content": ") datasets of larger size", + "type": "text" + }, + { + "bbox": [ + 238, + 481, + 253, + 492 + ], + "score": 0.84, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 480, + 257, + 494 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 257, + 480, + 294, + 493 + ], + "score": 0.89, + "content": "I ( \\alpha _ { \\mathrm { p r u n e } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 480, + 410, + 494 + ], + "score": 1.0, + "content": "can converge to a finite value", + "type": "text" + }, + { + "bbox": [ + 411, + 480, + 453, + 492 + ], + "score": 0.92, + "content": "I ( \\infty ) = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 480, + 506, + 494 + ], + "score": 1.0, + "content": "nat/example,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 492, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 506, + 504 + ], + "score": 1.0, + "content": "resulting in larger pruned datasets only adding useful non-redundant information. Since each new", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "example under Pareto optimal data pruning conveys finite information about the target decision", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 513, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 506, + 527 + ], + "score": 1.0, + "content": "boundary, as seen in Fig. 1F, the test error can decay at least exponentially in pruned dataset size", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "score": 1.0, + "content": "as in Fig. 1A. Classical results [30] have shown that training examples chosen by maximizing the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 535, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 505, + 548 + ], + "score": 1.0, + "content": "disagreement of a committee of student perceptrons can provide an asymptotically finite information", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 545, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 104, + 545, + 505, + 560 + ], + "score": 1.0, + "content": "rate, leading to exponential decay in test error. Intriguingly, the Pareto-optimal data pruning strategy", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "we study in this work leads to faster than exponential decay, because it includes (partial) information", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 568, + 369, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 369, + 581 + ], + "score": 1.0, + "content": "about the target function provided by the probe student (Fig. 11).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 330, + 506, + 581 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 591, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "An imperfect pruning metric yields a cross over from exponential to power law scaling. We", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 104, + 601, + 267, + 614 + ], + "score": 1.0, + "content": "next examine the case of nonzero angle", + "type": "text" + }, + { + "bbox": [ + 267, + 602, + 274, + 612 + ], + "score": 0.77, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 601, + 382, + 614 + ], + "score": 1.0, + "content": "between the probe student", + "type": "text" + }, + { + "bbox": [ + 383, + 602, + 406, + 614 + ], + "score": 0.9, + "content": "\\mathbf { J _ { \\mathrm { p r o b e } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 601, + 471, + 614 + ], + "score": 1.0, + "content": "and the teacher", + "type": "text" + }, + { + "bbox": [ + 471, + 602, + 480, + 612 + ], + "score": 0.5, + "content": "\\mathbf { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 601, + 506, + 614 + ], + "score": 1.0, + "content": ", such", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 611, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 506, + 626 + ], + "score": 1.0, + "content": "that the ranking of training examples by margin is no longer completely accurate (Fig. 2A). Retaining", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "the hard examples with smallest margin with respect to the probe student will always result in pruned", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 635, + 505, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 331, + 647 + ], + "score": 1.0, + "content": "datasets lying near the probe’s decision boundary. But if", + "type": "text" + }, + { + "bbox": [ + 331, + 635, + 338, + 644 + ], + "score": 0.82, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 635, + 505, + 647 + ], + "score": 1.0, + "content": "is large, such examples might be far from", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "the teacher’s decision boundary, and therefore could be less informative about the teacher (Fig. 2A).", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 451, + 668 + ], + "score": 1.0, + "content": "As a result our theory, confirmed by simulations, predicts that under nonzero angles", + "type": "text" + }, + { + "bbox": [ + 451, + 657, + 457, + 666 + ], + "score": 0.7, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 655, + 505, + 668 + ], + "score": 1.0, + "content": ", the Pareto", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 292, + 680 + ], + "score": 1.0, + "content": "optimal lower envelope of test error over both", + "type": "text" + }, + { + "bbox": [ + 293, + 668, + 308, + 678 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 667, + 326, + 680 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 326, + 667, + 333, + 679 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "initially scales exponentially as a function", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 117, + 691 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 678, + 175, + 690 + ], + "score": 0.93, + "content": "\\alpha _ { \\mathrm { p r u n e } } = f \\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 678, + 496, + 691 + ], + "score": 1.0, + "content": "but then crosses over to a power law (Fig. 2BCD). Indeed, at any given nonzero", + "type": "text" + }, + { + "bbox": [ + 496, + 678, + 502, + 688 + ], + "score": 0.75, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 678, + 506, + 691 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 104, + 688, + 207, + 703 + ], + "score": 1.0, + "content": "our theory reveals that as", + "type": "text" + }, + { + "bbox": [ + 207, + 690, + 223, + 700 + ], + "score": 0.88, + "content": "\\alpha _ { \\mathrm { t o t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 688, + 281, + 703 + ], + "score": 1.0, + "content": "(and therefore", + "type": "text" + }, + { + "bbox": [ + 281, + 690, + 305, + 701 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { p r u n e . } }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 688, + 506, + 703 + ], + "score": 1.0, + "content": ") becomes large, one cannot decrease test error any", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 310, + 713 + ], + "score": 1.0, + "content": "further by retaining less than a minimum fraction", + "type": "text" + }, + { + "bbox": [ + 310, + 700, + 340, + 712 + ], + "score": 0.92, + "content": "f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "of all available data. For example when", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 107, + 711, + 182, + 722 + ], + "score": 0.28, + "content": "\\theta = 1 0 ^ { \\circ } \\overset { \\cdot } { ( } \\theta = 2 0 ^ { \\circ } )", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 709, + 412, + 723 + ], + "score": 1.0, + "content": "one can do no better asymptotically than pruning down to", + "type": "text" + }, + { + "bbox": [ + 412, + 711, + 432, + 721 + ], + "score": 0.83, + "content": "24 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 711, + 457, + 722 + ], + "score": 0.76, + "content": "( 4 6 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 458, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "of the total", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 188, + 429 + ], + "score": 1.0, + "content": "data (Fig. 2CD). As", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 189, + 416, + 195, + 426 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 196, + 415, + 254, + 429 + ], + "score": 1.0, + "content": "approaches 0,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 254, + 415, + 284, + 428 + ], + "score": 0.91, + "content": "f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 284, + 415, + 505, + 429 + ], + "score": 1.0, + "content": "approaches 0, indicating that one can prune extremely", + "type": "text", + "cross_page": true + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 426, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 234, + 439 + ], + "score": 1.0, + "content": "aggressively to arbitrarily small", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 235, + 427, + 242, + 438 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 243, + 426, + 506, + 439 + ], + "score": 1.0, + "content": "while still improving performance, leading to at least exponential", + "type": "text", + "cross_page": true + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 437, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 221, + 451 + ], + "score": 1.0, + "content": "scaling for arbitrarily large", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 221, + 439, + 245, + 450 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 246, + 437, + 389, + 451 + ], + "score": 1.0, + "content": "in Fig. 2B. However, for nonzero", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 390, + 438, + 396, + 447 + ], + "score": 0.72, + "content": "\\theta", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 396, + 437, + 506, + 451 + ], + "score": 1.0, + "content": ", the lack of improvement", + "type": "text", + "cross_page": true + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 447, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 122, + 463 + ], + "score": 1.0, + "content": "for", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 122, + 448, + 173, + 460 + ], + "score": 0.93, + "content": "f < f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 174, + 447, + 209, + 463 + ], + "score": 1.0, + "content": "at large", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 209, + 450, + 233, + 460 + ], + "score": 0.89, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 234, + 447, + 506, + 463 + ], + "score": 1.0, + "content": "renders aggressive pruning ineffective. This result highlights the", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 326, + 473 + ], + "score": 1.0, + "content": "importance of finding high quality pruning metrics with", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 327, + 460, + 352, + 470 + ], + "score": 0.9, + "content": "\\theta \\approx 0", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 352, + 459, + 506, + 473 + ], + "score": 1.0, + "content": ". Such metrics can delay the cross over", + "type": "text", + "cross_page": true + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 469, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 349, + 484 + ], + "score": 1.0, + "content": "from exponential to power law scaling as pruned dataset size", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 350, + 471, + 374, + 482 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 374, + 469, + 506, + 484 + ], + "score": 1.0, + "content": "increases, by making aggressive", + "type": "text", + "cross_page": true + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 202, + 494 + ], + "score": 1.0, + "content": "pruning with very small", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 202, + 482, + 209, + 493 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 210, + 481, + 506, + 494 + ], + "score": 1.0, + "content": "highly effective. Strikingly, in App. Fig. 10 we demonstrate this cross-over", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 492, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 505 + ], + "score": 1.0, + "content": "in a real-world setting by showing that the test error on SVHN is bounded below by a power law", + "type": "text", + "cross_page": true + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "when the dataset is pruned by a probe ResNet18 under the EL2N metric, trained for 4 epochs (weak", + "type": "text", + "cross_page": true + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 514, + 460, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 460, + 527 + ], + "score": 1.0, + "content": "pruning metric) but not a probe ResNet18 trained for 40 epochs (strong pruning metric).", + "type": "text", + "cross_page": true + } + ], + "index": 37 + } + ], + "index": 40.5, + "bbox_fs": [ + 104, + 591, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 69, + 504, + 164 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 69, + 504, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 69, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 108, + 69, + 504, + 164 + ], + "score": 0.964, + "type": "image", + "image_path": "cacca5571c5984f8cd8e6159d713e3d9b0c958faf7b5c2d74cdd483350fe861e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 69, + 504, + 100.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 100.66666666666667, + 504, + 132.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 132.33333333333334, + 504, + 164.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 170, + 505, + 258 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 171, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 506, + 183 + ], + "score": 1.0, + "content": "Figure 3: Beating power law scaling in practice. A–D: Curves of test error against pruned dataset", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 181, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 505, + 194 + ], + "score": 1.0, + "content": "size in 4 settings. Pruning scores were EL2N [10] for CIFAR-10 and SVHN and memorization [13]", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 191, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 104, + 191, + 506, + 206 + ], + "score": 1.0, + "content": "for ImageNet. See App. B for all pruning/training details and App. D for similar ImageNet plots", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "with EL2N. Note solid curves reflect performance with a fixed total dataset size; if we prune more", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "aggressively with even larger datasets, scaling could improve further (e.g., dashed lines in A). Error", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 225, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 104, + 225, + 222, + 237 + ], + "score": 1.0, + "content": "curves with no data pruning", + "type": "text" + }, + { + "bbox": [ + 222, + 225, + 251, + 237 + ], + "score": 0.87, + "content": "( f = 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 225, + 446, + 237 + ], + "score": 1.0, + "content": "are labeled with their best-fit power law scaling", + "type": "text" + }, + { + "bbox": [ + 446, + 225, + 475, + 236 + ], + "score": 0.89, + "content": "\\sim \\alpha ^ { - \\nu }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 225, + 506, + 237 + ], + "score": 1.0, + "content": ". (Note", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 300, + 248 + ], + "score": 1.0, + "content": "that for SVHN in B an asymptotic constant error", + "type": "text" + }, + { + "bbox": [ + 300, + 236, + 385, + 248 + ], + "score": 0.92, + "content": "E ( P \\infty ) = 1 . \\bar { 1 } \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 235, + 506, + 248 + ], + "score": 1.0, + "content": "is subtracted from each of the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 331, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 331, + 260 + ], + "score": 1.0, + "content": "curves to visualize the power law scaling more clearly.)", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "image", + "bbox": [ + 107, + 276, + 319, + 387 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 276, + 319, + 387 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 276, + 319, + 387 + ], + "spans": [ + { + "bbox": [ + 107, + 276, + 319, + 387 + ], + "score": 0.963, + "type": "image", + "image_path": "750369d82ba6a10dff6b9975fe4186c91eb279da3bf5bc0fcb89abff4cdcfb6c.jpg" + } + ] + } + ], + "index": 14.5, + "virtual_lines": [ + { + "bbox": [ + 107, + 276, + 319, + 289.875 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 107, + 289.875, + 319, + 303.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 107, + 303.75, + 319, + 317.625 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 107, + 317.625, + 319, + 331.5 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 107, + 331.5, + 319, + 345.375 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 107, + 345.375, + 319, + 359.25 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 107, + 359.25, + 319, + 373.125 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 107, + 373.125, + 319, + 387.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 335, + 287, + 505, + 385 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 335, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 335, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "Figure 4: Data pruning improves transfer", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 334, + 298, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 334, + 298, + 505, + 310 + ], + "score": 1.0, + "content": "learning. A: CIFAR-10 performance of", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 334, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 334, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "a ViT pre-trained on all of ImageNet21K", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 335, + 320, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 335, + 320, + 505, + 331 + ], + "score": 1.0, + "content": "and fine-tuned on different pruned subsets", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 335, + 330, + 506, + 342 + ], + "spans": [ + { + "bbox": [ + 335, + 330, + 506, + 342 + ], + "score": 1.0, + "content": "of CIFAR-10 under the EL2N metric. B:", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 334, + 341, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 334, + 341, + 506, + 353 + ], + "score": 1.0, + "content": "CIFAR-10 performance of ResNet50s pre-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 335, + 353, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 335, + 353, + 506, + 363 + ], + "score": 1.0, + "content": "trained on different pruned subsets of Ima-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 334, + 363, + 507, + 375 + ], + "spans": [ + { + "bbox": [ + 334, + 363, + 507, + 375 + ], + "score": 1.0, + "content": "geNet1K and fine-tuned on all of CIFAR-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 334, + 374, + 350, + 386 + ], + "spans": [ + { + "bbox": [ + 334, + 374, + 350, + 386 + ], + "score": 1.0, + "content": "10.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + } + ], + "index": 18.75 + }, + { + "type": "text", + "bbox": [ + 107, + 415, + 505, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 415, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 188, + 429 + ], + "score": 1.0, + "content": "data (Fig. 2CD). As", + "type": "text" + }, + { + "bbox": [ + 189, + 416, + 195, + 426 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 415, + 254, + 429 + ], + "score": 1.0, + "content": "approaches 0,", + "type": "text" + }, + { + "bbox": [ + 254, + 415, + 284, + 428 + ], + "score": 0.91, + "content": "f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 415, + 505, + 429 + ], + "score": 1.0, + "content": "approaches 0, indicating that one can prune extremely", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 426, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 234, + 439 + ], + "score": 1.0, + "content": "aggressively to arbitrarily small", + "type": "text" + }, + { + "bbox": [ + 235, + 427, + 242, + 438 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 426, + 506, + 439 + ], + "score": 1.0, + "content": "while still improving performance, leading to at least exponential", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 437, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 221, + 451 + ], + "score": 1.0, + "content": "scaling for arbitrarily large", + "type": "text" + }, + { + "bbox": [ + 221, + 439, + 245, + 450 + ], + "score": 0.87, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 437, + 389, + 451 + ], + "score": 1.0, + "content": "in Fig. 2B. However, for nonzero", + "type": "text" + }, + { + "bbox": [ + 390, + 438, + 396, + 447 + ], + "score": 0.72, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 437, + 506, + 451 + ], + "score": 1.0, + "content": ", the lack of improvement", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 447, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 122, + 463 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 122, + 448, + 173, + 460 + ], + "score": 0.93, + "content": "f < f _ { \\mathrm { m i n } } ( \\theta )", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 447, + 209, + 463 + ], + "score": 1.0, + "content": "at large", + "type": "text" + }, + { + "bbox": [ + 209, + 450, + 233, + 460 + ], + "score": 0.89, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 447, + 506, + 463 + ], + "score": 1.0, + "content": "renders aggressive pruning ineffective. This result highlights the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 326, + 473 + ], + "score": 1.0, + "content": "importance of finding high quality pruning metrics with", + "type": "text" + }, + { + "bbox": [ + 327, + 460, + 352, + 470 + ], + "score": 0.9, + "content": "\\theta \\approx 0", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 459, + 506, + 473 + ], + "score": 1.0, + "content": ". Such metrics can delay the cross over", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 469, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 349, + 484 + ], + "score": 1.0, + "content": "from exponential to power law scaling as pruned dataset size", + "type": "text" + }, + { + "bbox": [ + 350, + 471, + 374, + 482 + ], + "score": 0.86, + "content": "\\alpha _ { \\mathrm { p r u n e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 374, + 469, + 506, + 484 + ], + "score": 1.0, + "content": "increases, by making aggressive", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 202, + 494 + ], + "score": 1.0, + "content": "pruning with very small", + "type": "text" + }, + { + "bbox": [ + 202, + 482, + 209, + 493 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 481, + 506, + 494 + ], + "score": 1.0, + "content": "highly effective. Strikingly, in App. Fig. 10 we demonstrate this cross-over", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 492, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 505 + ], + "score": 1.0, + "content": "in a real-world setting by showing that the test error on SVHN is bounded below by a power law", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 503, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 505, + 515 + ], + "score": 1.0, + "content": "when the dataset is pruned by a probe ResNet18 under the EL2N metric, trained for 4 epochs (weak", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 514, + 460, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 460, + 527 + ], + "score": 1.0, + "content": "pruning metric) but not a probe ResNet18 trained for 40 epochs (strong pruning metric).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 549, + 392, + 563 + ], + "lines": [ + { + "bbox": [ + 104, + 547, + 393, + 568 + ], + "spans": [ + { + "bbox": [ + 104, + 547, + 393, + 568 + ], + "score": 1.0, + "content": "4 Data pruning can beat power law scaling in practice", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 106, + 579, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 579, + 506, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 593 + ], + "score": 1.0, + "content": "Our theory of data pruning for the perceptron makes three striking predictions which can be tested in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 591, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 506, + 603 + ], + "score": 1.0, + "content": "more general settings, such as deep neural networks trained on benchmark datasets: (1) relative to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "random data pruning, keeping only the hardest examples should help when the initial dataset size", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 437, + 626 + ], + "score": 1.0, + "content": "is large, but hurt when it is small; (2) data pruning by retaining a fixed fraction", + "type": "text" + }, + { + "bbox": [ + 437, + 613, + 444, + 624 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 612, + 506, + 626 + ], + "score": 1.0, + "content": "of the hardest", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "examples should yield power law scaling, with exponent equal to that of random pruning, as the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "initial dataset size increases; (3) the test error optimized over both initial data set size and fraction", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "of data kept can trace out a Pareto optimal lower envelope that beats power law scaling of test error", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "as a function of pruned dataset size, through more aggressive pruning at larger initial dataset size.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "We verified all three of these predictions on ResNets trained on SVHN, CIFAR-10, and ImageNet", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "using varying amounts of initial dataset size and fractions of data kept under data pruning (compare", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "theory in Fig. 3A with deep learning experiments in Fig. 3BCD). In each experimental setting we see", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "better than power law scaling at larger initial data set sizes and more aggressive pruning. Moreover", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 711, + 504, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 504, + 724 + ], + "score": 1.0, + "content": "we would likely see even better scaling with even larger initial datasets (as in Fig.3A dashed lines).", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 45 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 69, + 504, + 164 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 69, + 504, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 69, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 108, + 69, + 504, + 164 + ], + "score": 0.964, + "type": "image", + "image_path": "cacca5571c5984f8cd8e6159d713e3d9b0c958faf7b5c2d74cdd483350fe861e.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 69, + 504, + 100.66666666666667 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 100.66666666666667, + 504, + 132.33333333333334 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 132.33333333333334, + 504, + 164.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 170, + 505, + 258 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 171, + 506, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 506, + 183 + ], + "score": 1.0, + "content": "Figure 3: Beating power law scaling in practice. A–D: Curves of test error against pruned dataset", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 181, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 181, + 505, + 194 + ], + "score": 1.0, + "content": "size in 4 settings. Pruning scores were EL2N [10] for CIFAR-10 and SVHN and memorization [13]", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 104, + 191, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 104, + 191, + 506, + 206 + ], + "score": 1.0, + "content": "for ImageNet. See App. B for all pruning/training details and App. D for similar ImageNet plots", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "with EL2N. Note solid curves reflect performance with a fixed total dataset size; if we prune more", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "aggressively with even larger datasets, scaling could improve further (e.g., dashed lines in A). Error", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 225, + 506, + 237 + ], + "spans": [ + { + "bbox": [ + 104, + 225, + 222, + 237 + ], + "score": 1.0, + "content": "curves with no data pruning", + "type": "text" + }, + { + "bbox": [ + 222, + 225, + 251, + 237 + ], + "score": 0.87, + "content": "( f = 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 225, + 446, + 237 + ], + "score": 1.0, + "content": "are labeled with their best-fit power law scaling", + "type": "text" + }, + { + "bbox": [ + 446, + 225, + 475, + 236 + ], + "score": 0.89, + "content": "\\sim \\alpha ^ { - \\nu }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 225, + 506, + 237 + ], + "score": 1.0, + "content": ". (Note", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 235, + 506, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 300, + 248 + ], + "score": 1.0, + "content": "that for SVHN in B an asymptotic constant error", + "type": "text" + }, + { + "bbox": [ + 300, + 236, + 385, + 248 + ], + "score": 0.92, + "content": "E ( P \\infty ) = 1 . \\bar { 1 } \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 235, + 506, + 248 + ], + "score": 1.0, + "content": "is subtracted from each of the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 246, + 331, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 331, + 260 + ], + "score": 1.0, + "content": "curves to visualize the power law scaling more clearly.)", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6.5 + } + ], + "index": 3.75 + }, + { + "type": "image", + "bbox": [ + 107, + 276, + 319, + 387 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 276, + 319, + 387 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 107, + 276, + 319, + 387 + ], + "spans": [ + { + "bbox": [ + 107, + 276, + 319, + 387 + ], + "score": 0.963, + "type": "image", + "image_path": "750369d82ba6a10dff6b9975fe4186c91eb279da3bf5bc0fcb89abff4cdcfb6c.jpg" + } + ] + } + ], + "index": 14.5, + "virtual_lines": [ + { + "bbox": [ + 107, + 276, + 319, + 289.875 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 107, + 289.875, + 319, + 303.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 107, + 303.75, + 319, + 317.625 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 107, + 317.625, + 319, + 331.5 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 107, + 331.5, + 319, + 345.375 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 107, + 345.375, + 319, + 359.25 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 107, + 359.25, + 319, + 373.125 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 107, + 373.125, + 319, + 387.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 335, + 287, + 505, + 385 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 335, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 335, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "Figure 4: Data pruning improves transfer", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 334, + 298, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 334, + 298, + 505, + 310 + ], + "score": 1.0, + "content": "learning. A: CIFAR-10 performance of", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 334, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 334, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "a ViT pre-trained on all of ImageNet21K", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 335, + 320, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 335, + 320, + 505, + 331 + ], + "score": 1.0, + "content": "and fine-tuned on different pruned subsets", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 335, + 330, + 506, + 342 + ], + "spans": [ + { + "bbox": [ + 335, + 330, + 506, + 342 + ], + "score": 1.0, + "content": "of CIFAR-10 under the EL2N metric. B:", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 334, + 341, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 334, + 341, + 506, + 353 + ], + "score": 1.0, + "content": "CIFAR-10 performance of ResNet50s pre-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 335, + 353, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 335, + 353, + 506, + 363 + ], + "score": 1.0, + "content": "trained on different pruned subsets of Ima-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 334, + 363, + 507, + 375 + ], + "spans": [ + { + "bbox": [ + 334, + 363, + 507, + 375 + ], + "score": 1.0, + "content": "geNet1K and fine-tuned on all of CIFAR-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 334, + 374, + 350, + 386 + ], + "spans": [ + { + "bbox": [ + 334, + 374, + 350, + 386 + ], + "score": 1.0, + "content": "10.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + } + ], + "index": 18.75 + }, + { + "type": "text", + "bbox": [ + 107, + 415, + 505, + 525 + ], + "lines": [], + "index": 32.5, + "bbox_fs": [ + 105, + 415, + 506, + 527 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 549, + 392, + 563 + ], + "lines": [ + { + "bbox": [ + 104, + 547, + 393, + 568 + ], + "spans": [ + { + "bbox": [ + 104, + 547, + 393, + 568 + ], + "score": 1.0, + "content": "4 Data pruning can beat power law scaling in practice", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 106, + 579, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 579, + 506, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 593 + ], + "score": 1.0, + "content": "Our theory of data pruning for the perceptron makes three striking predictions which can be tested in", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 591, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 506, + 603 + ], + "score": 1.0, + "content": "more general settings, such as deep neural networks trained on benchmark datasets: (1) relative to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "random data pruning, keeping only the hardest examples should help when the initial dataset size", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 612, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 437, + 626 + ], + "score": 1.0, + "content": "is large, but hurt when it is small; (2) data pruning by retaining a fixed fraction", + "type": "text" + }, + { + "bbox": [ + 437, + 613, + 444, + 624 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 445, + 612, + 506, + 626 + ], + "score": 1.0, + "content": "of the hardest", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "examples should yield power law scaling, with exponent equal to that of random pruning, as the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "initial dataset size increases; (3) the test error optimized over both initial data set size and fraction", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "of data kept can trace out a Pareto optimal lower envelope that beats power law scaling of test error", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "as a function of pruned dataset size, through more aggressive pruning at larger initial dataset size.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "We verified all three of these predictions on ResNets trained on SVHN, CIFAR-10, and ImageNet", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 692 + ], + "score": 1.0, + "content": "using varying amounts of initial dataset size and fractions of data kept under data pruning (compare", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 689, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 702 + ], + "score": 1.0, + "content": "theory in Fig. 3A with deep learning experiments in Fig. 3BCD). In each experimental setting we see", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 713 + ], + "score": 1.0, + "content": "better than power law scaling at larger initial data set sizes and more aggressive pruning. Moreover", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 711, + 504, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 504, + 724 + ], + "score": 1.0, + "content": "we would likely see even better scaling with even larger initial datasets (as in Fig.3A dashed lines).", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 579, + 506, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 505, + 237 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "Data pruning improves transfer learning. Modern foundation models are pre-trained on a large", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "initial dataset, and then transferred to other downstream tasks by fine-tuning on them. We therefore", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 107 + ], + "score": 1.0, + "content": "examined whether data-pruning can be effective for both reducing the amount of fine-tuning data and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "the amount of pre-training data. To this end, we first analyzed a vision transformer (ViT) pre-trained on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "ImageNet21K and then fine-tuned on different pruned subsets of CIFAR-10. Interestingly, pre-trained", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 388, + 140 + ], + "score": 1.0, + "content": "models allow for far more aggressive data pruning; fine-tuning on only", + "type": "text" + }, + { + "bbox": [ + 388, + 127, + 407, + 138 + ], + "score": 0.87, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "of CIFAR-10 can match", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 138, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 505, + 151 + ], + "score": 1.0, + "content": "or exceed performance obtained by fine tuning on all of CIFAR-10 (Fig. 4A). Furthermore Fig. 4A", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 149, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 506, + 162 + ], + "score": 1.0, + "content": "provides a new example of beating power law scaling in the setting of fine-tuning. Additionally, we", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 160, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 173 + ], + "score": 1.0, + "content": "examined the efficacy of pruning pre-training data by pre-training ResNet50s on different pruned", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 170, + 507, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 507, + 184 + ], + "score": 1.0, + "content": "subsets of ImageNet1K (exactly as in Fig. 3D) and then fine-tuning them on all of CIFAR-10.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 182, + 506, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 300, + 194 + ], + "score": 1.0, + "content": "Fig. 4B demonstrates pre-training on as little as", + "type": "text" + }, + { + "bbox": [ + 301, + 182, + 321, + 192 + ], + "score": 0.89, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 182, + 506, + 194 + ], + "score": 1.0, + "content": "of ImageNet can match or exceed CIFAR-10", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "performance obtained by pre-training on all of ImageNet. Thus intriguingly pruning pre-training data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "on an upstream task can still maintain high performance on a different downstream task. Overall", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "these results demonstrate the promise of data pruning in transfer learning for both the pre-training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 226, + 201, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 201, + 238 + ], + "score": 1.0, + "content": "and fine-tuning phases.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 7 + }, + { + "type": "image", + "bbox": [ + 110, + 247, + 506, + 433 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 247, + 506, + 433 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 247, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 110, + 247, + 506, + 433 + ], + "score": 0.973, + "type": "image", + "image_path": "a18df9bfde9ab270a6c571efccafab9598f464bed0af5ea554b36d734f2c5f70.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 110, + 247, + 506, + 309.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 110, + 309.0, + 506, + 371.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 110, + 371.0, + 506, + 433.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 439, + 506, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 439, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 506, + 452 + ], + "score": 1.0, + "content": "Figure 5: Dataset pruning at ImageNet scale. A: Spearman’s rank correlation between all pairs of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "ImageNet metric scores, along with hierarchical clustering (as provided by seaborn.clustermap).", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 459, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 104, + 459, + 506, + 475 + ], + "score": 1.0, + "content": "B: Benchmarking existing supervised metrics on ImageNet (top-5 validation accuracy). C: Comparing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "top-5 performance on ImageNet when pruning according to the best existing supervised metric", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "(memorization) and our supervised and self-supervised prototype metrics. In all 3 cases, training on", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 494, + 489, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 126, + 505 + ], + "score": 0.85, + "content": "80 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 494, + 282, + 507 + ], + "score": 1.0, + "content": "of ImageNet approximates training on", + "type": "text" + }, + { + "bbox": [ + 282, + 494, + 306, + 505 + ], + "score": 0.86, + "content": "100 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 494, + 489, + 507 + ], + "score": 1.0, + "content": ". See App. B for pruning and training details.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + } + ], + "index": 18.25 + }, + { + "type": "title", + "bbox": [ + 107, + 528, + 412, + 542 + ], + "lines": [ + { + "bbox": [ + 104, + 526, + 415, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 415, + 545 + ], + "score": 1.0, + "content": "5 Benchmarking supervised pruning metrics on ImageNet", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "We note that the majority of data pruning experiments have been performed on small-scale datasets", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "(i.e. variants of MNIST and CIFAR), while the few pruning metrics proposed for ImageNet have", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 575, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 505, + 587 + ], + "score": 1.0, + "content": "rarely been compared against baselines designed on smaller datasets. Therefore, it is currently unclear", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "how most pruning methods scale to ImageNet and which method is best. Motivated by how strongly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 596, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 610 + ], + "score": 1.0, + "content": "the quality of a pruning metric can impact performance in theory (Fig. 2), we decided to fill this", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 606, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 506, + 621 + ], + "score": 1.0, + "content": "knowledge gap by performing a systematic evaluation of 8 different supervised pruning metrics on", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "ImageNet: two variants of influence scores [13], two variants of EL2N [10], DDD [21], memorization", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 629, + 507, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 507, + 642 + ], + "score": 1.0, + "content": "[13], ensemble active learning [11], and forgetting [9]. See Section 2 for a review of these metrics.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 639, + 486, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 486, + 654 + ], + "score": 1.0, + "content": "Additionally, we include two new prototypicality metrics that we introduce in the next section.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "We first asked how consistent the rankings induced by different metrics are by computing the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "Spearman rank correlation between each pair of metrics (Fig. 5A). Interestingly, we found substantial", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "diversity across metrics, though some (EL2N, DDD, and memorization) were fairly similar with rank", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "correlations above 0.7. However, we observed marked performance differences between metrics:", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 308, + 712 + ], + "score": 1.0, + "content": "Fig 5BC shows test performance when a fraction", + "type": "text" + }, + { + "bbox": [ + 308, + 700, + 315, + 712 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "of the hardest examples under each metric are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "kept in the training set. Despite the success of many of these metrics on smaller datasets, only a", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 505, + 237 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "Data pruning improves transfer learning. Modern foundation models are pre-trained on a large", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "initial dataset, and then transferred to other downstream tasks by fine-tuning on them. We therefore", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 94, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 107 + ], + "score": 1.0, + "content": "examined whether data-pruning can be effective for both reducing the amount of fine-tuning data and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 105, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 505, + 118 + ], + "score": 1.0, + "content": "the amount of pre-training data. To this end, we first analyzed a vision transformer (ViT) pre-trained on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "ImageNet21K and then fine-tuned on different pruned subsets of CIFAR-10. Interestingly, pre-trained", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 388, + 140 + ], + "score": 1.0, + "content": "models allow for far more aggressive data pruning; fine-tuning on only", + "type": "text" + }, + { + "bbox": [ + 388, + 127, + 407, + 138 + ], + "score": 0.87, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "of CIFAR-10 can match", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 138, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 505, + 151 + ], + "score": 1.0, + "content": "or exceed performance obtained by fine tuning on all of CIFAR-10 (Fig. 4A). Furthermore Fig. 4A", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 149, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 506, + 162 + ], + "score": 1.0, + "content": "provides a new example of beating power law scaling in the setting of fine-tuning. Additionally, we", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 160, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 173 + ], + "score": 1.0, + "content": "examined the efficacy of pruning pre-training data by pre-training ResNet50s on different pruned", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 170, + 507, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 507, + 184 + ], + "score": 1.0, + "content": "subsets of ImageNet1K (exactly as in Fig. 3D) and then fine-tuning them on all of CIFAR-10.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 182, + 506, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 300, + 194 + ], + "score": 1.0, + "content": "Fig. 4B demonstrates pre-training on as little as", + "type": "text" + }, + { + "bbox": [ + 301, + 182, + 321, + 192 + ], + "score": 0.89, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 182, + 506, + 194 + ], + "score": 1.0, + "content": "of ImageNet can match or exceed CIFAR-10", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "performance obtained by pre-training on all of ImageNet. Thus intriguingly pruning pre-training data", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "on an upstream task can still maintain high performance on a different downstream task. Overall", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 228 + ], + "score": 1.0, + "content": "these results demonstrate the promise of data pruning in transfer learning for both the pre-training", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 226, + 201, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 201, + 238 + ], + "score": 1.0, + "content": "and fine-tuning phases.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 72, + 507, + 238 + ] + }, + { + "type": "image", + "bbox": [ + 110, + 247, + 506, + 433 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 247, + 506, + 433 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 247, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 110, + 247, + 506, + 433 + ], + "score": 0.973, + "type": "image", + "image_path": "a18df9bfde9ab270a6c571efccafab9598f464bed0af5ea554b36d734f2c5f70.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 110, + 247, + 506, + 309.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 110, + 309.0, + 506, + 371.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 110, + 371.0, + 506, + 433.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 439, + 506, + 506 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 439, + 506, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 506, + 452 + ], + "score": 1.0, + "content": "Figure 5: Dataset pruning at ImageNet scale. A: Spearman’s rank correlation between all pairs of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "ImageNet metric scores, along with hierarchical clustering (as provided by seaborn.clustermap).", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 459, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 104, + 459, + 506, + 475 + ], + "score": 1.0, + "content": "B: Benchmarking existing supervised metrics on ImageNet (top-5 validation accuracy). C: Comparing", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "top-5 performance on ImageNet when pruning according to the best existing supervised metric", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "(memorization) and our supervised and self-supervised prototype metrics. In all 3 cases, training on", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 494, + 489, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 126, + 505 + ], + "score": 0.85, + "content": "80 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 494, + 282, + 507 + ], + "score": 1.0, + "content": "of ImageNet approximates training on", + "type": "text" + }, + { + "bbox": [ + 282, + 494, + 306, + 505 + ], + "score": 0.86, + "content": "100 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 494, + 489, + 507 + ], + "score": 1.0, + "content": ". See App. B for pruning and training details.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + } + ], + "index": 18.25 + }, + { + "type": "title", + "bbox": [ + 107, + 528, + 412, + 542 + ], + "lines": [ + { + "bbox": [ + 104, + 526, + 415, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 526, + 415, + 545 + ], + "score": 1.0, + "content": "5 Benchmarking supervised pruning metrics on ImageNet", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "We note that the majority of data pruning experiments have been performed on small-scale datasets", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "(i.e. variants of MNIST and CIFAR), while the few pruning metrics proposed for ImageNet have", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 575, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 505, + 587 + ], + "score": 1.0, + "content": "rarely been compared against baselines designed on smaller datasets. Therefore, it is currently unclear", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 598 + ], + "score": 1.0, + "content": "how most pruning methods scale to ImageNet and which method is best. Motivated by how strongly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 596, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 610 + ], + "score": 1.0, + "content": "the quality of a pruning metric can impact performance in theory (Fig. 2), we decided to fill this", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 606, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 506, + 621 + ], + "score": 1.0, + "content": "knowledge gap by performing a systematic evaluation of 8 different supervised pruning metrics on", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "ImageNet: two variants of influence scores [13], two variants of EL2N [10], DDD [21], memorization", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 629, + 507, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 507, + 642 + ], + "score": 1.0, + "content": "[13], ensemble active learning [11], and forgetting [9]. See Section 2 for a review of these metrics.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 639, + 486, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 486, + 654 + ], + "score": 1.0, + "content": "Additionally, we include two new prototypicality metrics that we introduce in the next section.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 552, + 507, + 654 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "We first asked how consistent the rankings induced by different metrics are by computing the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "Spearman rank correlation between each pair of metrics (Fig. 5A). Interestingly, we found substantial", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "diversity across metrics, though some (EL2N, DDD, and memorization) were fairly similar with rank", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 701 + ], + "score": 1.0, + "content": "correlations above 0.7. However, we observed marked performance differences between metrics:", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 308, + 712 + ], + "score": 1.0, + "content": "Fig 5BC shows test performance when a fraction", + "type": "text" + }, + { + "bbox": [ + 308, + 700, + 315, + 712 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "of the hardest examples under each metric are", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 506, + 723 + ], + "score": 1.0, + "content": "kept in the training set. Despite the success of many of these metrics on smaller datasets, only a", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "few still match performance obtained by training on the full dataset, when selecting a significantly", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 245, + 96 + ], + "score": 1.0, + "content": "smaller training subset (i.e. about", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 245, + 83, + 265, + 94 + ], + "score": 0.89, + "content": "8 0 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 266, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "of ImageNet). Nonetheless, most metrics continue to beat", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "score": 1.0, + "content": "random pruning, with memorization in particular demonstrating strong performance (Fig. 5C). We", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "note that data pruning on ImageNet may be more difficult than data pruning on other datasets, because", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 406, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 406, + 130 + ], + "score": 1.0, + "content": "ImageNet is already carefully curated to filter out uninformative examples.", + "type": "text", + "cross_page": true + } + ], + "index": 4 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 655, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "few still match performance obtained by training on the full dataset, when selecting a significantly", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 245, + 96 + ], + "score": 1.0, + "content": "smaller training subset (i.e. about", + "type": "text" + }, + { + "bbox": [ + 245, + 83, + 265, + 94 + ], + "score": 0.89, + "content": "8 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "of ImageNet). Nonetheless, most metrics continue to beat", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "score": 1.0, + "content": "random pruning, with memorization in particular demonstrating strong performance (Fig. 5C). We", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "note that data pruning on ImageNet may be more difficult than data pruning on other datasets, because", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 406, + 130 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 406, + 130 + ], + "score": 1.0, + "content": "ImageNet is already carefully curated to filter out uninformative examples.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "We found that all pruning metrics amplify class imbalance, which results in degraded performance.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 236, + 156 + ], + "score": 1.0, + "content": "To solve this we used a simple", + "type": "text" + }, + { + "bbox": [ + 236, + 144, + 256, + 154 + ], + "score": 0.88, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "class balancing ratio for all ImageNet experiments. Further", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 374, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 374, + 167 + ], + "score": 1.0, + "content": "details and baselines without class balancing are shown in App. H.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 184, + 441, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 183, + 443, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 443, + 201 + ], + "score": 1.0, + "content": "6 Self-supervised data pruning through a prototypicality metric", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 211, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "score": 1.0, + "content": "Fig. 5 shows many data pruning metrics do not scale well to ImageNet, while the few that do require", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 223, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 506, + 235 + ], + "score": 1.0, + "content": "substantial amounts of compute. Furthermore, all these metrics require labels, thereby limiting their", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 506, + 245 + ], + "score": 1.0, + "content": "ability to prune data for large-scale foundation models trained on massive unlabeled datasets [12].", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 423, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 423, + 257 + ], + "score": 1.0, + "content": "Thus there is a clear need for simple, scalable, self-supervised pruning metrics.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 107, + 260, + 505, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 399, + 273 + ], + "score": 1.0, + "content": "To compute a self-supervised pruning metric for ImageNet, we perform", + "type": "text" + }, + { + "bbox": [ + 400, + 261, + 406, + 271 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 260, + 506, + 273 + ], + "score": 1.0, + "content": "-means clustering in the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "embedding space of an ImageNet pre-trained self-supervised model (here: SWaV [35]), and define", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 281, + 507, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 507, + 296 + ], + "score": 1.0, + "content": "the difficulty of each data point by the Euclidean distance to its nearest cluster centroid, or prototype.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Thus easy (hard) examples are the most (least) prototypical. Encouragingly, in Fig. 5C, we find", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 305, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 506, + 317 + ], + "score": 1.0, + "content": "our self-supervised prototype metric matches or exceeds the performance of the best supervised", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 236, + 327 + ], + "score": 1.0, + "content": "metric, memorization, until only", + "type": "text" + }, + { + "bbox": [ + 236, + 315, + 271, + 326 + ], + "score": 0.89, + "content": "70 \\mathrm { - } 8 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 316, + 506, + 327 + ], + "score": 1.0, + "content": "of the data is kept, despite the fact that our metric does not", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "score": 1.0, + "content": "use labels and is much simpler and cheaper to compute than many previously proposed supervised", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 338, + 463, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 463, + 349 + ], + "score": 1.0, + "content": "metrics. See App. Fig. 9 for further scaling experiments using the self-supervised metric.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 353, + 505, + 463 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "score": 1.0, + "content": "To assess whether the clusters found by our metric align with ImageNet classes, we compared their", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 505, + 376 + ], + "score": 1.0, + "content": "overlaps in Fig. 6A. Interestingly, we found alignment for some but not all classes. For example, class", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 375, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 506, + 388 + ], + "score": 1.0, + "content": "categories such as snakes were largely aligned to a small number of unsupervised clusters, while", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "other classes were dispersed across many such clusters. If class information is available, we can", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "score": 1.0, + "content": "enforce alignment between clusters and classes by simply computing a single prototype for each", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "class (by averaging the embeddings of all examples of this class). While originally intended to be an", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "score": 1.0, + "content": "additional baseline metric (called supervised prototypes, light blue in Fig 5C), this metric remarkably", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "outperforms other supervised metrics and largely matches the performance of memorization, which", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "is prohibitively expensive to compute. Moreover, the performance of the best self-supervised and", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 449, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 449, + 466 + ], + "score": 1.0, + "content": "supervised metrics are similar, demonstrating the promise of self-supervised pruning.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 108, + 468, + 504, + 501 + ], + "lines": [ + { + "bbox": [ + 106, + 468, + 506, + 481 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 452, + 481 + ], + "score": 1.0, + "content": "One important choice for the self-supervised prototype metric is the number of clusters", + "type": "text" + }, + { + "bbox": [ + 452, + 469, + 459, + 478 + ], + "score": 0.71, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 468, + 506, + 481 + ], + "score": 1.0, + "content": ". We found,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 316, + 492 + ], + "score": 1.0, + "content": "reassuringly, our results were robust to this choice:", + "type": "text" + }, + { + "bbox": [ + 316, + 479, + 324, + 489 + ], + "score": 0.71, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "can deviate one order of magnitude more or", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "less than the true number of classes (i.e. 1000 for ImageNet) without affecting performance (App. F).", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 506, + 505, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "To better understand example difficulty under various metrics, we visualize extremal images for our", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 517, + 507, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 507, + 530 + ], + "score": 1.0, + "content": "self-supervised prototype metric and the memorization metric for one class (Fig 6B,C). Qualitatively,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 529, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 540 + ], + "score": 1.0, + "content": "easy examples correspond to highly similar, redundant images, while hard examples look like", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 539, + 486, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 486, + 552 + ], + "score": 1.0, + "content": "idiosyncratic outliers. See App. E, Figs. 12,13,14,15,16,17,18,19 for more classes and metrics.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "image", + "bbox": [ + 106, + 565, + 503, + 659 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 565, + 503, + 659 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 565, + 503, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 503, + 659 + ], + "score": 0.96, + "type": "image", + "image_path": "c6388f541d225b33d830efef18469e869ad3adaa127067232e64f07f1eb633af.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 106, + 565, + 503, + 596.3333333333334 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 106, + 596.3333333333334, + 503, + 627.6666666666667 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 106, + 627.6666666666667, + 503, + 659.0000000000001 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 665, + 505, + 709 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "Figure 6: A: Heat map where each row denotes the probability that images in a given cluster come", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "from each ImageNet class. B: The four easiest and hardest images under our self-supervised pruning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "metric and the best previously published supervised metric (memorization, shown in C) for ImageNet", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 698, + 209, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 209, + 711 + ], + "score": 1.0, + "content": "class 100 (black swan).", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5 + } + ], + "index": 40.75 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 128 + ], + "lines": [], + "index": 2, + "bbox_fs": [ + 105, + 72, + 505, + 130 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 131, + 505, + 146 + ], + "score": 1.0, + "content": "We found that all pruning metrics amplify class imbalance, which results in degraded performance.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 236, + 156 + ], + "score": 1.0, + "content": "To solve this we used a simple", + "type": "text" + }, + { + "bbox": [ + 236, + 144, + 256, + 154 + ], + "score": 0.88, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "class balancing ratio for all ImageNet experiments. Further", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 374, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 374, + 167 + ], + "score": 1.0, + "content": "details and baselines without class balancing are shown in App. H.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 131, + 505, + 167 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 184, + 441, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 183, + 443, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 183, + 443, + 201 + ], + "score": 1.0, + "content": "6 Self-supervised data pruning through a prototypicality metric", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 211, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "score": 1.0, + "content": "Fig. 5 shows many data pruning metrics do not scale well to ImageNet, while the few that do require", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 223, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 506, + 235 + ], + "score": 1.0, + "content": "substantial amounts of compute. Furthermore, all these metrics require labels, thereby limiting their", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 506, + 245 + ], + "score": 1.0, + "content": "ability to prune data for large-scale foundation models trained on massive unlabeled datasets [12].", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 423, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 423, + 257 + ], + "score": 1.0, + "content": "Thus there is a clear need for simple, scalable, self-supervised pruning metrics.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 212, + 506, + 257 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 260, + 505, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 399, + 273 + ], + "score": 1.0, + "content": "To compute a self-supervised pruning metric for ImageNet, we perform", + "type": "text" + }, + { + "bbox": [ + 400, + 261, + 406, + 271 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 260, + 506, + 273 + ], + "score": 1.0, + "content": "-means clustering in the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "embedding space of an ImageNet pre-trained self-supervised model (here: SWaV [35]), and define", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 281, + 507, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 281, + 507, + 296 + ], + "score": 1.0, + "content": "the difficulty of each data point by the Euclidean distance to its nearest cluster centroid, or prototype.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Thus easy (hard) examples are the most (least) prototypical. Encouragingly, in Fig. 5C, we find", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 305, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 305, + 506, + 317 + ], + "score": 1.0, + "content": "our self-supervised prototype metric matches or exceeds the performance of the best supervised", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 236, + 327 + ], + "score": 1.0, + "content": "metric, memorization, until only", + "type": "text" + }, + { + "bbox": [ + 236, + 315, + 271, + 326 + ], + "score": 0.89, + "content": "70 \\mathrm { - } 8 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 316, + 506, + 327 + ], + "score": 1.0, + "content": "of the data is kept, despite the fact that our metric does not", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 339 + ], + "score": 1.0, + "content": "use labels and is much simpler and cheaper to compute than many previously proposed supervised", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 338, + 463, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 463, + 349 + ], + "score": 1.0, + "content": "metrics. See App. Fig. 9 for further scaling experiments using the self-supervised metric.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 260, + 507, + 349 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 353, + 505, + 463 + ], + "lines": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "score": 1.0, + "content": "To assess whether the clusters found by our metric align with ImageNet classes, we compared their", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 505, + 376 + ], + "score": 1.0, + "content": "overlaps in Fig. 6A. Interestingly, we found alignment for some but not all classes. For example, class", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 375, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 506, + 388 + ], + "score": 1.0, + "content": "categories such as snakes were largely aligned to a small number of unsupervised clusters, while", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "other classes were dispersed across many such clusters. If class information is available, we can", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "score": 1.0, + "content": "enforce alignment between clusters and classes by simply computing a single prototype for each", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "class (by averaging the embeddings of all examples of this class). While originally intended to be an", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 506, + 432 + ], + "score": 1.0, + "content": "additional baseline metric (called supervised prototypes, light blue in Fig 5C), this metric remarkably", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "outperforms other supervised metrics and largely matches the performance of memorization, which", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "is prohibitively expensive to compute. Moreover, the performance of the best self-supervised and", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 449, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 449, + 466 + ], + "score": 1.0, + "content": "supervised metrics are similar, demonstrating the promise of self-supervised pruning.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 352, + 506, + 466 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 468, + 504, + 501 + ], + "lines": [ + { + "bbox": [ + 106, + 468, + 506, + 481 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 452, + 481 + ], + "score": 1.0, + "content": "One important choice for the self-supervised prototype metric is the number of clusters", + "type": "text" + }, + { + "bbox": [ + 452, + 469, + 459, + 478 + ], + "score": 0.71, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 468, + 506, + 481 + ], + "score": 1.0, + "content": ". We found,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 316, + 492 + ], + "score": 1.0, + "content": "reassuringly, our results were robust to this choice:", + "type": "text" + }, + { + "bbox": [ + 316, + 479, + 324, + 489 + ], + "score": 0.71, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 478, + 506, + 492 + ], + "score": 1.0, + "content": "can deviate one order of magnitude more or", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "less than the true number of classes (i.e. 1000 for ImageNet) without affecting performance (App. F).", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 468, + 506, + 502 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 506, + 505, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 519 + ], + "score": 1.0, + "content": "To better understand example difficulty under various metrics, we visualize extremal images for our", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 517, + 507, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 507, + 530 + ], + "score": 1.0, + "content": "self-supervised prototype metric and the memorization metric for one class (Fig 6B,C). Qualitatively,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 529, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 540 + ], + "score": 1.0, + "content": "easy examples correspond to highly similar, redundant images, while hard examples look like", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 539, + 486, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 486, + 552 + ], + "score": 1.0, + "content": "idiosyncratic outliers. See App. E, Figs. 12,13,14,15,16,17,18,19 for more classes and metrics.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 506, + 507, + 552 + ] + }, + { + "type": "image", + "bbox": [ + 106, + 565, + 503, + 659 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 565, + 503, + 659 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 565, + 503, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 503, + 659 + ], + "score": 0.96, + "type": "image", + "image_path": "c6388f541d225b33d830efef18469e869ad3adaa127067232e64f07f1eb633af.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 106, + 565, + 503, + 596.3333333333334 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 106, + 596.3333333333334, + 503, + 627.6666666666667 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 106, + 627.6666666666667, + 503, + 659.0000000000001 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 665, + 505, + 709 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "Figure 6: A: Heat map where each row denotes the probability that images in a given cluster come", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "score": 1.0, + "content": "from each ImageNet class. B: The four easiest and hardest images under our self-supervised pruning", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "metric and the best previously published supervised metric (memorization, shown in C) for ImageNet", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 698, + 209, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 209, + 711 + ], + "score": 1.0, + "content": "class 100 (black swan).", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5 + } + ], + "index": 40.75 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 180, + 84 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 181, + 87 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 181, + 87 + ], + "score": 1.0, + "content": "7 Discussion", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 95, + 505, + 139 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "score": 1.0, + "content": "Summary. We have shown, both in theory and practice, how to break beyond slow power law", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "scaling of error versus dataset size to faster exponential scaling, through data pruning. Additionally we", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 506, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 432, + 130 + ], + "score": 1.0, + "content": "have developed a simple self-supervised pruning metric that enables us to discard", + "type": "text" + }, + { + "bbox": [ + 432, + 118, + 451, + 128 + ], + "score": 0.87, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 117, + 506, + 130 + ], + "score": 1.0, + "content": "of ImageNet", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "without sacrificing performance, on par with the best and most compute intensive supervised metric.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 505, + 293 + ], + "lines": [ + { + "bbox": [ + 105, + 150, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 164 + ], + "score": 1.0, + "content": "Limitations. The most notable limitation is that achieving exponential scaling requires a high", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 162, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 175 + ], + "score": 1.0, + "content": "quality data pruning metric. Since most metrics developed for smaller datasets scale poorly to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "ImageNet, our results emphasize the importance of future work in identifying high quality, scalable", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "metrics. Our self-supervised metric provides a strong initial baseline. Moreover, a key advantage of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "data pruning is reduced computational cost due to training on a smaller dataset for the same number", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "of epochs as the full dataset (see App. C). However, we found that performance often increased when", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "training on the pruned dataset for the same number of iterations as on the full dataset, resulting in", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 506, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 506, + 240 + ], + "score": 1.0, + "content": "the same training time, but additional training epochs. However, this performance gain saturated", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "before training time on the pruned dataset approached that on the whole dataset (App. J) thereby still", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 249, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 263 + ], + "score": 1.0, + "content": "yielding a computational efficiency gain. Overall this tradeoff between accuracy and training time on", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "pruned data is important to consider in evaluating potential gains due to data pruning. Finally, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "found that class-balancing was essential to maintain performance on data subsets (App. H). Future", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "work will be required to identify ways to effectively select the appropriate amount of class-balancing.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 305, + 505, + 371 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "Ethical considerations. A potential negative societal impact could be that data-pruning leads to", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "unfair outcomes for certain groups. We have done a preliminary analysis of how data-pruning affects", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "score": 1.0, + "content": "performance on individual ImageNet classes (App. I), finding no substantial differential effects across", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 338, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 350 + ], + "score": 1.0, + "content": "classes. However proper fairness tests specific to deployment settings should always be conducted on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 348, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 363 + ], + "score": 1.0, + "content": "every model, whether trained on pruned data or not. Additionally, we analyzed the impact of pruning", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 360, + 236, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 236, + 372 + ], + "score": 1.0, + "content": "on OOD performance (App. K).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 382, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 382, + 505, + 395 + ], + "score": 1.0, + "content": "Outlook: Towards foundation datasets. We believe the most promising future direction is the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 394, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 406 + ], + "score": 1.0, + "content": "further development of scalable, unsupervised data pruning metrics. Indeed our theory predicts that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 404, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 506, + 418 + ], + "score": 1.0, + "content": "the application of pruning metrics on larger scale datasets should yield larger gains by allowing more", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 428 + ], + "score": 1.0, + "content": "aggressive pruning. This makes data pruning especially exciting for use on the massive unlabeled", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "datasets used to train large foundation models (e.g. 400M image-text pairs for CLIP [36], 3.5B", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 437, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 506, + 450 + ], + "score": 1.0, + "content": "Instagram images [37], 650M images for the DALLE-2 encoder [38], 780B tokens for PALM", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 460 + ], + "score": 1.0, + "content": "[39]). If highly pruned versions of these datasets can be used to train a large number of different", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "models, one can conceive of such carefully chosen data subsets as foundation datasets in which", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "score": 1.0, + "content": "the initial computational cost of data pruning can be amortized across efficiency gains in training", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "many downstream models, just at the initial computational cost of training foundation models is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "amortized across the efficiency gains of fine-tuning across many downstream tasks. Together, our", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 501, + 507, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 507, + 516 + ], + "score": 1.0, + "content": "results demonstrate the promise and potential of data pruning for large-scale training and pretraining.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 163, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 165, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 165, + 544 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 111, + 553, + 506, + 723 + ], + "lines": [ + { + "bbox": [ + 111, + 554, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 111, + 554, + 505, + 566 + ], + "score": 1.0, + "content": "[1] Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory Diamos, Heewoo Jun, Hassan", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 565, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 127, + 565, + 506, + 577 + ], + "score": 1.0, + "content": "Kianinejad, Md Patwary, Mostofa Ali, Yang Yang, and Yanqi Zhou. Deep learning scaling is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 576, + 390, + 588 + ], + "spans": [ + { + "bbox": [ + 127, + 576, + 390, + 588 + ], + "score": 1.0, + "content": "predictable, empirically. arXiv preprint arXiv:1712.00409, 2017.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 110, + 589, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 110, + 589, + 506, + 604 + ], + "score": 1.0, + "content": "[2] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 599, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 126, + 599, + 506, + 615 + ], + "score": 1.0, + "content": "Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 127, + 612, + 325, + 624 + ], + "spans": [ + { + "bbox": [ + 127, + 612, + 325, + 624 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2001.08361, 2020.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 110, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 110, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "[3] Tom Henighan, Jared Kaplan, Mor Katz, Mark Chen, Christopher Hesse, Jacob Jackson,", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 127, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Heewoo Jun, Tom B Brown, Prafulla Dhariwal, Scott Gray, et al. Scaling laws for autoregressive", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 126, + 649, + 378, + 660 + ], + "spans": [ + { + "bbox": [ + 126, + 649, + 378, + 660 + ], + "score": 1.0, + "content": "generative modeling. arXiv preprint arXiv:2010.14701, 2020.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 111, + 663, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 111, + 663, + 506, + 676 + ], + "score": 1.0, + "content": "[4] Jonathan S. Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. A constructive", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 126, + 673, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 126, + 673, + 506, + 689 + ], + "score": 1.0, + "content": "prediction of the generalization error across scales. International Conference on Learning", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 127, + 686, + 221, + 697 + ], + "spans": [ + { + "bbox": [ + 127, + 686, + 221, + 697 + ], + "score": 1.0, + "content": "Representations, 2020.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 111, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 111, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "[5] Mitchell A Gordon, Kevin Duh, and Jared Kaplan. Data and parameter scaling laws for", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 127, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "neural machine translation. In Proceedings of the 2021 Conference on Empirical Methods in", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 43.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 301, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 755 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 755 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 180, + 84 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 181, + 87 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 181, + 87 + ], + "score": 1.0, + "content": "7 Discussion", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 95, + 505, + 139 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 108 + ], + "score": 1.0, + "content": "Summary. We have shown, both in theory and practice, how to break beyond slow power law", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "scaling of error versus dataset size to faster exponential scaling, through data pruning. Additionally we", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 506, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 432, + 130 + ], + "score": 1.0, + "content": "have developed a simple self-supervised pruning metric that enables us to discard", + "type": "text" + }, + { + "bbox": [ + 432, + 118, + 451, + 128 + ], + "score": 0.87, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 117, + 506, + 130 + ], + "score": 1.0, + "content": "of ImageNet", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "without sacrificing performance, on par with the best and most compute intensive supervised metric.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 95, + 506, + 140 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 505, + 293 + ], + "lines": [ + { + "bbox": [ + 105, + 150, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 164 + ], + "score": 1.0, + "content": "Limitations. The most notable limitation is that achieving exponential scaling requires a high", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 162, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 175 + ], + "score": 1.0, + "content": "quality data pruning metric. Since most metrics developed for smaller datasets scale poorly to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "ImageNet, our results emphasize the importance of future work in identifying high quality, scalable", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "metrics. Our self-supervised metric provides a strong initial baseline. Moreover, a key advantage of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "data pruning is reduced computational cost due to training on a smaller dataset for the same number", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "of epochs as the full dataset (see App. C). However, we found that performance often increased when", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "training on the pruned dataset for the same number of iterations as on the full dataset, resulting in", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 506, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 506, + 240 + ], + "score": 1.0, + "content": "the same training time, but additional training epochs. However, this performance gain saturated", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "before training time on the pruned dataset approached that on the whole dataset (App. J) thereby still", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 249, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 263 + ], + "score": 1.0, + "content": "yielding a computational efficiency gain. Overall this tradeoff between accuracy and training time on", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "pruned data is important to consider in evaluating potential gains due to data pruning. Finally, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 505, + 284 + ], + "score": 1.0, + "content": "found that class-balancing was essential to maintain performance on data subsets (App. H). Future", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "work will be required to identify ways to effectively select the appropriate amount of class-balancing.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 150, + 506, + 295 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 305, + 505, + 371 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "Ethical considerations. A potential negative societal impact could be that data-pruning leads to", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "unfair outcomes for certain groups. We have done a preliminary analysis of how data-pruning affects", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 340 + ], + "score": 1.0, + "content": "performance on individual ImageNet classes (App. I), finding no substantial differential effects across", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 338, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 505, + 350 + ], + "score": 1.0, + "content": "classes. However proper fairness tests specific to deployment settings should always be conducted on", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 348, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 363 + ], + "score": 1.0, + "content": "every model, whether trained on pruned data or not. Additionally, we analyzed the impact of pruning", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 360, + 236, + 372 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 236, + 372 + ], + "score": 1.0, + "content": "on OOD performance (App. K).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 304, + 506, + 372 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 106, + 382, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 382, + 505, + 395 + ], + "score": 1.0, + "content": "Outlook: Towards foundation datasets. We believe the most promising future direction is the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 394, + 506, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 406 + ], + "score": 1.0, + "content": "further development of scalable, unsupervised data pruning metrics. Indeed our theory predicts that", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 404, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 506, + 418 + ], + "score": 1.0, + "content": "the application of pruning metrics on larger scale datasets should yield larger gains by allowing more", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 428 + ], + "score": 1.0, + "content": "aggressive pruning. This makes data pruning especially exciting for use on the massive unlabeled", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "datasets used to train large foundation models (e.g. 400M image-text pairs for CLIP [36], 3.5B", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 437, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 506, + 450 + ], + "score": 1.0, + "content": "Instagram images [37], 650M images for the DALLE-2 encoder [38], 780B tokens for PALM", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 448, + 506, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 460 + ], + "score": 1.0, + "content": "[39]). If highly pruned versions of these datasets can be used to train a large number of different", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "models, one can conceive of such carefully chosen data subsets as foundation datasets in which", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "score": 1.0, + "content": "the initial computational cost of data pruning can be amortized across efficiency gains in training", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "many downstream models, just at the initial computational cost of training foundation models is", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "amortized across the efficiency gains of fine-tuning across many downstream tasks. Together, our", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 501, + 507, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 507, + 516 + ], + "score": 1.0, + "content": "results demonstrate the promise and potential of data pruning for large-scale training and pretraining.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 29.5, + "bbox_fs": [ + 104, + 382, + 507, + 516 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 163, + 542 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 165, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 165, + 544 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 36 + }, + { + "type": "list", + "bbox": [ + 111, + 553, + 506, + 723 + ], + "lines": [ + { + "bbox": [ + 111, + 554, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 111, + 554, + 505, + 566 + ], + "score": 1.0, + "content": "[1] Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory Diamos, Heewoo Jun, Hassan", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 565, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 127, + 565, + 506, + 577 + ], + "score": 1.0, + "content": "Kianinejad, Md Patwary, Mostofa Ali, Yang Yang, and Yanqi Zhou. Deep learning scaling is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 576, + 390, + 588 + ], + "spans": [ + { + "bbox": [ + 127, + 576, + 390, + 588 + ], + "score": 1.0, + "content": "predictable, empirically. arXiv preprint arXiv:1712.00409, 2017.", + "type": "text" + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 589, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 110, + 589, + 506, + 604 + ], + "score": 1.0, + "content": "[2] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child,", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 599, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 126, + 599, + 506, + 615 + ], + "score": 1.0, + "content": "Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 127, + 612, + 325, + 624 + ], + "spans": [ + { + "bbox": [ + 127, + 612, + 325, + 624 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2001.08361, 2020.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 626, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 110, + 626, + 506, + 640 + ], + "score": 1.0, + "content": "[3] Tom Henighan, Jared Kaplan, Mor Katz, Mark Chen, Christopher Hesse, Jacob Jackson,", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 127, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "Heewoo Jun, Tom B Brown, Prafulla Dhariwal, Scott Gray, et al. Scaling laws for autoregressive", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 126, + 649, + 378, + 660 + ], + "spans": [ + { + "bbox": [ + 126, + 649, + 378, + 660 + ], + "score": 1.0, + "content": "generative modeling. arXiv preprint arXiv:2010.14701, 2020.", + "type": "text" + } + ], + "index": 45, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 663, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 111, + 663, + 506, + 676 + ], + "score": 1.0, + "content": "[4] Jonathan S. Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. A constructive", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 673, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 126, + 673, + 506, + 689 + ], + "score": 1.0, + "content": "prediction of the generalization error across scales. International Conference on Learning", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 127, + 686, + 221, + 697 + ], + "spans": [ + { + "bbox": [ + 127, + 686, + 221, + 697 + ], + "score": 1.0, + "content": "Representations, 2020.", + "type": "text" + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 111, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 111, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "[5] Mitchell A Gordon, Kevin Duh, and Jared Kaplan. Data and parameter scaling laws for", + "type": "text" + } + ], + "index": 49, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "neural machine translation. In Proceedings of the 2021 Conference on Empirical Methods in", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 126, + 71, + 507, + 87 + ], + "spans": [ + { + "bbox": [ + 126, + 71, + 507, + 87 + ], + "score": 1.0, + "content": "Natural Language Processing, pages 5915–5922, Online and Punta Cana, Dominican Republic,", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 82, + 373, + 98 + ], + "spans": [ + { + "bbox": [ + 126, + 82, + 373, + 98 + ], + "score": 1.0, + "content": "November 2021. Association for Computational Linguistics.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 110, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "[6] Danny Hernandez, Jared Kaplan, Tom Henighan, and Sam McCandlish. Scaling laws for", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 110, + 327, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 327, + 124 + ], + "score": 1.0, + "content": "transfer. arXiv preprint arXiv:2102.01293, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 126, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 110, + 126, + 505, + 138 + ], + "score": 1.0, + "content": "[7] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transform-", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 136, + 308, + 150 + ], + "spans": [ + { + "bbox": [ + 126, + 136, + 308, + 150 + ], + "score": 1.0, + "content": "ers. arXiv preprint arXiv:2106.04560, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 109, + 151, + 506, + 164 + ], + "spans": [ + { + "bbox": [ + 109, + 151, + 506, + 164 + ], + "score": 1.0, + "content": "[8] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 163, + 507, + 175 + ], + "spans": [ + { + "bbox": [ + 127, + 163, + 507, + 175 + ], + "score": 1.0, + "content": "Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 173, + 493, + 187 + ], + "spans": [ + { + "bbox": [ + 127, + 173, + 493, + 187 + ], + "score": 1.0, + "content": "Training compute-optimal large language models. arXiv preprint arXiv:2203.15556, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 110, + 188, + 507, + 202 + ], + "spans": [ + { + "bbox": [ + 110, + 188, + 507, + 202 + ], + "score": 1.0, + "content": "[9] Mariya Toneva, Alessandro Sordoni, Remi Tachet des Combes, Adam Trischler, Yoshua Bengio,", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 127, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "and Geoffrey J Gordon. An empirical study of example forgetting during deep neural network", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 210, + 230, + 225 + ], + "spans": [ + { + "bbox": [ + 127, + 210, + 230, + 225 + ], + "score": 1.0, + "content": "learning. In ICLR, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 225, + 507, + 240 + ], + "spans": [ + { + "bbox": [ + 104, + 225, + 507, + 240 + ], + "score": 1.0, + "content": "[10] Mansheej Paul, Surya Ganguli, and Gintare Karolina Dziugaite. Deep learning on a data diet:", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 235, + 507, + 252 + ], + "spans": [ + { + "bbox": [ + 125, + 235, + 507, + 252 + ], + "score": 1.0, + "content": "Finding important examples early in training. Adv. Neural Inf. Process. Syst., 34, December", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 246, + 155, + 261 + ], + "spans": [ + { + "bbox": [ + 126, + 246, + 155, + 261 + ], + "score": 1.0, + "content": "2021.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "[11] Kashyap Chitta, José M Álvarez, Elmar Haussmann, and Clément Farabet. Training data subset", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 274, + 490, + 288 + ], + "spans": [ + { + "bbox": [ + 127, + 274, + 490, + 288 + ], + "score": 1.0, + "content": "search with ensemble active learning. IEEE Trans. Intell. Transp. Syst., pages 1–12, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "[12] Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 300, + 506, + 314 + ], + "spans": [ + { + "bbox": [ + 127, + 300, + 506, + 314 + ], + "score": 1.0, + "content": "Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. On the", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 310, + 475, + 325 + ], + "spans": [ + { + "bbox": [ + 125, + 310, + 475, + 325 + ], + "score": 1.0, + "content": "opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 324, + 507, + 341 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 507, + 341 + ], + "score": 1.0, + "content": "[13] Vitaly Feldman and Chiyuan Zhang. What neural networks memorize and why: Discovering", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 337, + 492, + 351 + ], + "spans": [ + { + "bbox": [ + 127, + 337, + 492, + 351 + ], + "score": 1.0, + "content": "the long tail via influence estimation. Adv. Neural Inf. Process. Syst., 33:2881–2891, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 353, + 412, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 412, + 365 + ], + "score": 1.0, + "content": "[14] Burr Settles. Active learning literature survey. Technical Report, 2009.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "[15] Antoine Bordes, Seyda Ertekin, Jason Weston, Léon Botton, and Nello Cristianini. Fast kernel", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 378, + 434, + 392 + ], + "spans": [ + { + "bbox": [ + 127, + 378, + 434, + 392 + ], + "score": 1.0, + "content": "classifiers with online and active learning. J. Mach. Learn. Res., 6(9), 2005.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 394, + 507, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 507, + 408 + ], + "score": 1.0, + "content": "[16] Zeyad Ali Sami Emam, Hong-Min Chu, Ping-Yeh Chiang, Wojciech Czaja, Richard Leapman,", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 403, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 125, + 403, + 506, + 420 + ], + "score": 1.0, + "content": "Micah Goldblum, and Tom Goldstein. Active learning at the ImageNet scale. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 415, + 232, + 429 + ], + "spans": [ + { + "bbox": [ + 127, + 415, + 232, + 429 + ], + "score": 1.0, + "content": "arXiv:2111.12880, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 432, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 506, + 443 + ], + "score": 1.0, + "content": "[17] Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 442, + 333, + 455 + ], + "spans": [ + { + "bbox": [ + 127, + 442, + 333, + 455 + ], + "score": 1.0, + "content": "approach. arXiv preprint arXiv:1708.00489, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 457, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 471 + ], + "score": 1.0, + "content": "[18] Siddharth Karamcheti, Ranjay Krishna, Li Fei-Fei, and Christopher D Manning. Mind your", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 127, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "outliers! Investigating the negative impact of outliers on active learning for visual question", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 479, + 337, + 492 + ], + "spans": [ + { + "bbox": [ + 126, + 479, + 337, + 492 + ], + "score": 1.0, + "content": "answering. arXiv preprint arXiv:2107.02331, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "score": 1.0, + "content": "[19] Baharan Mirzasoleiman, Jeff Bilmes, and Jure Leskovec. Coresets for data-efficient training", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 127, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "of machine learning models. In Hal Daumé Iii and Aarti Singh, editors, Proceedings of the", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 127, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "37th International Conference on Machine Learning, volume 119 of Proceedings of Machine", + "type": "text", + "cross_page": true + } + ], + "index": 35 + }, + { + "bbox": [ + 124, + 527, + 341, + 540 + ], + "spans": [ + { + "bbox": [ + 124, + 527, + 341, + 540 + ], + "score": 1.0, + "content": "Learning Research, pages 6950–6960. PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 542, + 507, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 507, + 556 + ], + "score": 1.0, + "content": "[20] V Birodkar, H Mobahi, and S Bengio. Semantic redundancies in Image-Classification datasets:", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 553, + 394, + 567 + ], + "spans": [ + { + "bbox": [ + 127, + 553, + 146, + 567 + ], + "score": 1.0, + "content": "The", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 146, + 554, + 165, + 564 + ], + "score": 0.86, + "content": "10 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 166, + 553, + 394, + 567 + ], + "score": 1.0, + "content": "you don’t need. arXiv preprint arXiv:1901.11409, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "[21] Kristof Meding, Luca M. Schulze Buschoff, Robert Geirhos, and Felix A. Wichmann. Trivial or", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 580, + 507, + 594 + ], + "spans": [ + { + "bbox": [ + 127, + 580, + 507, + 594 + ], + "score": 1.0, + "content": "impossible—dichotomous data difficulty masks model differences (on ImageNet and beyond).", + "type": "text", + "cross_page": true + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 591, + 388, + 605 + ], + "spans": [ + { + "bbox": [ + 127, + 591, + 388, + 605 + ], + "score": 1.0, + "content": "In International Conference on Learning Representations, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 606, + 507, + 620 + ], + "spans": [ + { + "bbox": [ + 107, + 606, + 507, + 620 + ], + "score": 1.0, + "content": "[22] Utkarsh Sharma and Jared Kaplan. Scaling laws from the data manifold dimension. Journal of", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 617, + 320, + 631 + ], + "spans": [ + { + "bbox": [ + 127, + 617, + 320, + 631 + ], + "score": 1.0, + "content": "Machine Learning Research, 23(9):1–34, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 630, + 507, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 507, + 647 + ], + "score": 1.0, + "content": "[23] Yasaman Bahri, Ethan Dyer, Jared Kaplan, Jaehoon Lee, and Utkarsh Sharma. Explaining", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 642, + 333, + 656 + ], + "spans": [ + { + "bbox": [ + 126, + 642, + 333, + 656 + ], + "score": 1.0, + "content": "neural scaling laws. CoRR, abs/2102.06701, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 658, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 506, + 672 + ], + "score": 1.0, + "content": "[24] Jonathan S. Rosenfeld. Scaling Laws for Deep Learning. PhD thesis, Massachusetts Institute of", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 669, + 229, + 683 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 229, + 683 + ], + "score": 1.0, + "content": "Technology, USA, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 47, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 684, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 506, + 698 + ], + "score": 1.0, + "content": "[25] A Engel and C V den Broeck. Statistical Mechanics of Learning. Cambridge Univ. Press, 2001.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_start_line": true + }, + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "[26] Madhu Advani, Subhaneil Lahiri, and Surya Ganguli. Statistical mechanics of complex neural", + "type": "text", + "cross_page": true + } + ], + "index": 49, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 710, + 486, + 726 + ], + "spans": [ + { + "bbox": [ + 125, + 710, + 486, + 726 + ], + "score": 1.0, + "content": "systems and high dimensional data. J. Stat. Mech: Theory Exp., 2013(03):P03014, 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 50, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 72, + 507, + 87 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 507, + 87 + ], + "score": 1.0, + "content": "[27] Yasaman Bahri, Jonathan Kadmon, Jeffrey Pennington, Sam S Schoenholz, Jascha Sohl-", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 83, + 506, + 98 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 98 + ], + "score": 1.0, + "content": "Dickstein, and Surya Ganguli. Statistical mechanics of deep learning. Annual Review of", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 94, + 293, + 108 + ], + "spans": [ + { + "bbox": [ + 127, + 94, + 293, + 108 + ], + "score": 1.0, + "content": "Condensed Matter Physics, March 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "[28] Lenka Zdeborová and Florent Krzakala. Statistical physics of inference: thresholds and", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 121, + 359, + 135 + ], + "spans": [ + { + "bbox": [ + 127, + 121, + 359, + 135 + ], + "score": 1.0, + "content": "algorithms. Adv. Phys., 65(5):453–552, September 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 137, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 151 + ], + "score": 1.0, + "content": "[29] E Gardner. The space of interactions in neural network models. J. of Physics A, 21:257–270,", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 149, + 154, + 161 + ], + "spans": [ + { + "bbox": [ + 127, + 149, + 154, + 161 + ], + "score": 1.0, + "content": "1988.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "[30] H S Seung, H Sompolinsky, and N Tishby. Statistical mechanics of learning from examples.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 176, + 257, + 188 + ], + "spans": [ + { + "bbox": [ + 127, + 176, + 257, + 188 + ], + "score": 1.0, + "content": "Phys. Rev. A, 45(8):6056, 1992.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 191, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 506, + 205 + ], + "score": 1.0, + "content": "[31] Yoav Freund, H Sebastian Seung, Eli Shamir, and Naftali Tishby. Information, prediction, and", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 202, + 374, + 216 + ], + "spans": [ + { + "bbox": [ + 127, + 202, + 374, + 216 + ], + "score": 1.0, + "content": "query by committee. Adv. Neural Inf. Process. Syst., 5, 1992.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 216, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 234 + ], + "score": 1.0, + "content": "[32] Hai-Jun Zhou. Active online learning in the binary perceptron problem. Commun. Theor. Phys.,", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 229, + 236, + 243 + ], + "spans": [ + { + "bbox": [ + 127, + 229, + 236, + 243 + ], + "score": 1.0, + "content": "71(2):243, February 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "[33] Hugo Cui, Luca Saglietti, and Lenka Zdeborovà. Large deviations in the perceptron model and", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 256, + 289, + 270 + ], + "spans": [ + { + "bbox": [ + 126, + 256, + 289, + 270 + ], + "score": 1.0, + "content": "consequences for active learning, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 272, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 506, + 286 + ], + "score": 1.0, + "content": "[34] M Mezard, G Parisi, and M A Virasoro. Spin glass theory and beyond. World scientific", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 284, + 200, + 297 + ], + "spans": [ + { + "bbox": [ + 126, + 284, + 200, + 297 + ], + "score": 1.0, + "content": "Singapore, 1987.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 298, + 507, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 507, + 312 + ], + "score": 1.0, + "content": "[35] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 311, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 127, + 311, + 506, + 323 + ], + "score": 1.0, + "content": "Unsupervised learning of visual features by contrasting cluster assignments. In H. Larochelle,", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 319, + 507, + 336 + ], + "spans": [ + { + "bbox": [ + 125, + 319, + 507, + 336 + ], + "score": 1.0, + "content": "M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin, editors, Advances in Neural Information", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 332, + 456, + 346 + ], + "spans": [ + { + "bbox": [ + 127, + 332, + 456, + 346 + ], + "score": 1.0, + "content": "Processing Systems, volume 33, pages 9912–9924. Curran Associates, Inc., 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "score": 1.0, + "content": "[36] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal,", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 125, + 368, + 507, + 386 + ], + "spans": [ + { + "bbox": [ + 125, + 368, + 507, + 386 + ], + "score": 1.0, + "content": "models from natural language supervision. In International Conference on Machine Learning,", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 381, + 261, + 393 + ], + "spans": [ + { + "bbox": [ + 126, + 381, + 261, + 393 + ], + "score": 1.0, + "content": "pages 8748–8763. PMLR, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 398, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 506, + 410 + ], + "score": 1.0, + "content": "[37] Dhruv Mahajan, Ross Girshick, Vignesh Ramanathan, Kaiming He, Manohar Paluri, Yixuan Li,", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 407, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 127, + 407, + 506, + 421 + ], + "score": 1.0, + "content": "Ashwin Bharambe, and Laurens Van Der Maaten. Exploring the limits of weakly supervised", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 419, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 126, + 419, + 506, + 433 + ], + "score": 1.0, + "content": "pretraining. In Proceedings of the European conference on computer vision (ECCV), pages", + "type": "text", + "cross_page": true + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 429, + 193, + 443 + ], + "spans": [ + { + "bbox": [ + 127, + 429, + 193, + 443 + ], + "score": 1.0, + "content": "181–196, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "score": 1.0, + "content": "[38] Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 456, + 497, + 471 + ], + "spans": [ + { + "bbox": [ + 126, + 456, + 497, + 471 + ], + "score": 1.0, + "content": "text-conditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 472, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 506, + 486 + ], + "score": 1.0, + "content": "[39] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 483, + 507, + 497 + ], + "spans": [ + { + "bbox": [ + 127, + 483, + 507, + 497 + ], + "score": 1.0, + "content": "Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm:", + "type": "text", + "cross_page": true + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 495, + 465, + 509 + ], + "spans": [ + { + "bbox": [ + 127, + 495, + 465, + 509 + ], + "score": 1.0, + "content": "Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "[40] Priya Goyal, Quentin Duval, Jeremy Reizenstein, Matthew Leavitt, Min Xu, Benjamin", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 520, + 507, + 536 + ], + "spans": [ + { + "bbox": [ + 126, + 520, + 507, + 536 + ], + "score": 1.0, + "content": "Lefaudeux, Mannat Singh, Vinicius Reis, Mathilde Caron, Piotr Bojanowski, Armand Joulin,", + "type": "text", + "cross_page": true + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 532, + 476, + 546 + ], + "spans": [ + { + "bbox": [ + 127, + 532, + 476, + 546 + ], + "score": 1.0, + "content": "and Ishan Misra. VISSL. https://github.com/facebookresearch/vissl, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 547, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 563 + ], + "score": 1.0, + "content": "[41] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 127, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual", + "type": "text", + "cross_page": true + } + ], + "index": 38 + }, + { + "bbox": [ + 126, + 570, + 485, + 583 + ], + "spans": [ + { + "bbox": [ + 126, + 570, + 485, + 583 + ], + "score": 1.0, + "content": "recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 587, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 506, + 599 + ], + "score": 1.0, + "content": "[42] Kaiyu Yang, Klint Qinami, Li Fei-Fei, Jia Deng, and Olga Russakovsky. Towards fairer datasets:", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 597, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 127, + 597, + 506, + 611 + ], + "score": 1.0, + "content": "Filtering and balancing the distribution of the people subtree in the ImageNet hierarchy. In", + "type": "text", + "cross_page": true + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 607, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 126, + 607, + 506, + 623 + ], + "score": 1.0, + "content": "Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pages", + "type": "text", + "cross_page": true + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 619, + 194, + 631 + ], + "spans": [ + { + "bbox": [ + 127, + 619, + 194, + 631 + ], + "score": 1.0, + "content": "547–558, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 635, + 507, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 507, + 649 + ], + "score": 1.0, + "content": "[43] Yuki M Asano, Christian Rupprecht, Andrew Zisserman, and Andrea Vedaldi. PASS:", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 127, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "An ImageNet replacement for self-supervised pretraining without humans. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 657, + 231, + 669 + ], + "spans": [ + { + "bbox": [ + 127, + 657, + 231, + 669 + ], + "score": 1.0, + "content": "arXiv:2109.13228, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 673, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 673, + 209, + 685 + ], + "score": 1.0, + "content": "[44] Ross Wightman.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 220, + 673, + 339, + 687 + ], + "score": 1.0, + "content": "Pytorch image models.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 340, + 673, + 506, + 687 + ], + "score": 1.0, + "content": "https://github.com/rwightman/", + "type": "text", + "cross_page": true + } + ], + "index": 47, + "is_list_start_line": true + }, + { + "bbox": [ + 124, + 683, + 264, + 697 + ], + "spans": [ + { + "bbox": [ + 124, + 683, + 264, + 697 + ], + "score": 1.0, + "content": "pytorch-image-models, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "[45] Justin M Johnson and Taghi M Khoshgoftaar. Survey on deep learning with class imbalance.", + "type": "text", + "cross_page": true + } + ], + "index": 49, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 710, + 282, + 724 + ], + "spans": [ + { + "bbox": [ + 126, + 710, + 282, + 724 + ], + "score": 1.0, + "content": "Journal of Big Data, 6(1):1–54, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 50, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "[46] Robert Geirhos, Kantharaju Narayanappa, Benjamin Mitzkus, Tizian Thieringer, Matthias", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "Bethge, Felix A Wichmann, and Wieland Brendel. Partial success in closing the gap between", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 506, + 107 + ], + "score": 1.0, + "content": "human and machine vision. Advances in Neural Information Processing Systems, 34:23885–", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 105, + 183, + 118 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 183, + 118 + ], + "score": 1.0, + "content": "23899, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 120, + 506, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 120, + 506, + 133 + ], + "score": 1.0, + "content": "[47] Felix A Wichmann, David HJ Janssen, Robert Geirhos, Guillermo Aguilar, Heiko H Schütt,", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 131, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 127, + 131, + 506, + 144 + ], + "score": 1.0, + "content": "Marianne Maertens, and Matthias Bethge. Methods and measurements to compare men against", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 142, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 127, + 142, + 506, + 155 + ], + "score": 1.0, + "content": "machines. Electronic Imaging, Human Vision and Electronic Imaging, 2017(14):36–45, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 108, + 158, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 108, + 158, + 505, + 169 + ], + "score": 1.0, + "content": "[48] Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 167, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 127, + 167, + 506, + 180 + ], + "score": 1.0, + "content": "Felix A Wichmann. Generalisation in humans and deep neural networks. In Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 180, + 286, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 180, + 286, + 191 + ], + "score": 1.0, + "content": "Information Processing Systems, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "[49] Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 127, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 216, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 127, + 216, + 506, + 229 + ], + "score": 1.0, + "content": "improves accuracy and robustness. In International Conference on Learning Representations,", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 226, + 153, + 239 + ], + "spans": [ + { + "bbox": [ + 127, + 226, + 153, + 239 + ], + "score": 1.0, + "content": "2019.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "[50] Haohan Wang, Songwei Ge, Zachary Lipton, and Eric P Xing. Learning robust global repre-", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 252, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 126, + 252, + 506, + 266 + ], + "score": 1.0, + "content": "sentations by penalizing local predictive power. Advances in Neural Information Processing", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 264, + 204, + 275 + ], + "spans": [ + { + "bbox": [ + 127, + 264, + 204, + 275 + ], + "score": 1.0, + "content": "Systems, 32, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 277, + 507, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 507, + 292 + ], + "score": 1.0, + "content": "[51] Robert Geirhos, Kristof Meding, and Felix A Wichmann. Beyond accuracy: quantifying trial-", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 127, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "by-trial behaviour of CNNs and humans by measuring error consistency. Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 300, + 301, + 313 + ], + "spans": [ + { + "bbox": [ + 127, + 300, + 301, + 313 + ], + "score": 1.0, + "content": "Information Processing Systems, 33, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 314, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 328 + ], + "score": 1.0, + "content": "[52] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers:", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 127, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Surpassing human-level performance on ImageNet classification. In Proceedings of the IEEE", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 336, + 416, + 350 + ], + "spans": [ + { + "bbox": [ + 127, + 336, + 416, + 350 + ], + "score": 1.0, + "content": "International Conference on Computer Vision, pages 1026–1034, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "[53] John P Miller, Rohan Taori, Aditi Raghunathan, Shiori Sagawa, Pang Wei Koh, Vaishaal", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 361, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 127, + 361, + 506, + 376 + ], + "score": 1.0, + "content": "Shankar, Percy Liang, Yair Carmon, and Ludwig Schmidt. Accuracy on the line: on the strong", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 127, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 127, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "correlation between out-of-distribution and in-distribution generalization. In International", + "type": "text", + "cross_page": true + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 384, + 399, + 398 + ], + "spans": [ + { + "bbox": [ + 127, + 384, + 399, + 398 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pages 7721–7735. PMLR, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_end_line": true + } + ], + "index": 43.5, + "bbox_fs": [ + 110, + 554, + 506, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 51, + 507, + 725 + ], + "lines": [ + { + "bbox": [ + 126, + 71, + 507, + 87 + ], + "spans": [ + { + "bbox": [ + 126, + 71, + 507, + 87 + ], + "score": 1.0, + "content": "Natural Language Processing, pages 5915–5922, Online and Punta Cana, Dominican Republic,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 82, + 373, + 98 + ], + "spans": [ + { + "bbox": [ + 126, + 82, + 373, + 98 + ], + "score": 1.0, + "content": "November 2021. Association for Computational Linguistics.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 110, + 99, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 110, + 99, + 506, + 113 + ], + "score": 1.0, + "content": "[6] Danny Hernandez, Jared Kaplan, Tom Henighan, and Sam McCandlish. Scaling laws for", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 110, + 327, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 110, + 327, + 124 + ], + "score": 1.0, + "content": "transfer. arXiv preprint arXiv:2102.01293, 2021.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 110, + 126, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 110, + 126, + 505, + 138 + ], + "score": 1.0, + "content": "[7] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transform-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 126, + 136, + 308, + 150 + ], + "spans": [ + { + "bbox": [ + 126, + 136, + 308, + 150 + ], + "score": 1.0, + "content": "ers. arXiv preprint arXiv:2106.04560, 2021.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 109, + 151, + 506, + 164 + ], + "spans": [ + { + "bbox": [ + 109, + 151, + 506, + 164 + ], + "score": 1.0, + "content": "[8] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 163, + 507, + 175 + ], + "spans": [ + { + "bbox": [ + 127, + 163, + 507, + 175 + ], + "score": 1.0, + "content": "Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 173, + 493, + 187 + ], + "spans": [ + { + "bbox": [ + 127, + 173, + 493, + 187 + ], + "score": 1.0, + "content": "Training compute-optimal large language models. arXiv preprint arXiv:2203.15556, 2022.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 110, + 188, + 507, + 202 + ], + "spans": [ + { + "bbox": [ + 110, + 188, + 507, + 202 + ], + "score": 1.0, + "content": "[9] Mariya Toneva, Alessandro Sordoni, Remi Tachet des Combes, Adam Trischler, Yoshua Bengio,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 199, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 127, + 199, + 505, + 213 + ], + "score": 1.0, + "content": "and Geoffrey J Gordon. An empirical study of example forgetting during deep neural network", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 210, + 230, + 225 + ], + "spans": [ + { + "bbox": [ + 127, + 210, + 230, + 225 + ], + "score": 1.0, + "content": "learning. In ICLR, 2019.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 225, + 507, + 240 + ], + "spans": [ + { + "bbox": [ + 104, + 225, + 507, + 240 + ], + "score": 1.0, + "content": "[10] Mansheej Paul, Surya Ganguli, and Gintare Karolina Dziugaite. Deep learning on a data diet:", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 125, + 235, + 507, + 252 + ], + "spans": [ + { + "bbox": [ + 125, + 235, + 507, + 252 + ], + "score": 1.0, + "content": "Finding important examples early in training. Adv. Neural Inf. Process. Syst., 34, December", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 246, + 155, + 261 + ], + "spans": [ + { + "bbox": [ + 126, + 246, + 155, + 261 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "[11] Kashyap Chitta, José M Álvarez, Elmar Haussmann, and Clément Farabet. Training data subset", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 274, + 490, + 288 + ], + "spans": [ + { + "bbox": [ + 127, + 274, + 490, + 288 + ], + "score": 1.0, + "content": "search with ensemble active learning. IEEE Trans. Intell. Transp. Syst., pages 1–12, 2021.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "[12] Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 300, + 506, + 314 + ], + "spans": [ + { + "bbox": [ + 127, + 300, + 506, + 314 + ], + "score": 1.0, + "content": "Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. On the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 310, + 475, + 325 + ], + "spans": [ + { + "bbox": [ + 125, + 310, + 475, + 325 + ], + "score": 1.0, + "content": "opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258, 2021.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 324, + 507, + 341 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 507, + 341 + ], + "score": 1.0, + "content": "[13] Vitaly Feldman and Chiyuan Zhang. What neural networks memorize and why: Discovering", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 337, + 492, + 351 + ], + "spans": [ + { + "bbox": [ + 127, + 337, + 492, + 351 + ], + "score": 1.0, + "content": "the long tail via influence estimation. Adv. Neural Inf. Process. Syst., 33:2881–2891, 2020.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 353, + 412, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 412, + 365 + ], + "score": 1.0, + "content": "[14] Burr Settles. Active learning literature survey. Technical Report, 2009.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 505, + 381 + ], + "score": 1.0, + "content": "[15] Antoine Bordes, Seyda Ertekin, Jason Weston, Léon Botton, and Nello Cristianini. Fast kernel", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 378, + 434, + 392 + ], + "spans": [ + { + "bbox": [ + 127, + 378, + 434, + 392 + ], + "score": 1.0, + "content": "classifiers with online and active learning. J. Mach. Learn. Res., 6(9), 2005.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 394, + 507, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 507, + 408 + ], + "score": 1.0, + "content": "[16] Zeyad Ali Sami Emam, Hong-Min Chu, Ping-Yeh Chiang, Wojciech Czaja, Richard Leapman,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 125, + 403, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 125, + 403, + 506, + 420 + ], + "score": 1.0, + "content": "Micah Goldblum, and Tom Goldstein. Active learning at the ImageNet scale. arXiv preprint", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 415, + 232, + 429 + ], + "spans": [ + { + "bbox": [ + 127, + 415, + 232, + 429 + ], + "score": 1.0, + "content": "arXiv:2111.12880, 2021.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 432, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 506, + 443 + ], + "score": 1.0, + "content": "[17] Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 442, + 333, + 455 + ], + "spans": [ + { + "bbox": [ + 127, + 442, + 333, + 455 + ], + "score": 1.0, + "content": "approach. arXiv preprint arXiv:1708.00489, 2017.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 457, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 506, + 471 + ], + "score": 1.0, + "content": "[18] Siddharth Karamcheti, Ranjay Krishna, Li Fei-Fei, and Christopher D Manning. Mind your", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 127, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "outliers! Investigating the negative impact of outliers on active learning for visual question", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 479, + 337, + 492 + ], + "spans": [ + { + "bbox": [ + 126, + 479, + 337, + 492 + ], + "score": 1.0, + "content": "answering. arXiv preprint arXiv:2107.02331, 2021.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 508 + ], + "score": 1.0, + "content": "[19] Baharan Mirzasoleiman, Jeff Bilmes, and Jure Leskovec. Coresets for data-efficient training", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 127, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "of machine learning models. In Hal Daumé Iii and Aarti Singh, editors, Proceedings of the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 127, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "37th International Conference on Machine Learning, volume 119 of Proceedings of Machine", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 124, + 527, + 341, + 540 + ], + "spans": [ + { + "bbox": [ + 124, + 527, + 341, + 540 + ], + "score": 1.0, + "content": "Learning Research, pages 6950–6960. PMLR, 2020.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 542, + 507, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 507, + 556 + ], + "score": 1.0, + "content": "[20] V Birodkar, H Mobahi, and S Bengio. Semantic redundancies in Image-Classification datasets:", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 553, + 394, + 567 + ], + "spans": [ + { + "bbox": [ + 127, + 553, + 146, + 567 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 146, + 554, + 165, + 564 + ], + "score": 0.86, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 553, + 394, + 567 + ], + "score": 1.0, + "content": "you don’t need. arXiv preprint arXiv:1901.11409, 2019.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 506, + 582 + ], + "score": 1.0, + "content": "[21] Kristof Meding, Luca M. Schulze Buschoff, Robert Geirhos, and Felix A. Wichmann. Trivial or", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 580, + 507, + 594 + ], + "spans": [ + { + "bbox": [ + 127, + 580, + 507, + 594 + ], + "score": 1.0, + "content": "impossible—dichotomous data difficulty masks model differences (on ImageNet and beyond).", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 591, + 388, + 605 + ], + "spans": [ + { + "bbox": [ + 127, + 591, + 388, + 605 + ], + "score": 1.0, + "content": "In International Conference on Learning Representations, 2022.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 606, + 507, + 620 + ], + "spans": [ + { + "bbox": [ + 107, + 606, + 507, + 620 + ], + "score": 1.0, + "content": "[22] Utkarsh Sharma and Jared Kaplan. Scaling laws from the data manifold dimension. Journal of", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 617, + 320, + 631 + ], + "spans": [ + { + "bbox": [ + 127, + 617, + 320, + 631 + ], + "score": 1.0, + "content": "Machine Learning Research, 23(9):1–34, 2022.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 630, + 507, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 507, + 647 + ], + "score": 1.0, + "content": "[23] Yasaman Bahri, Ethan Dyer, Jared Kaplan, Jaehoon Lee, and Utkarsh Sharma. Explaining", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 126, + 642, + 333, + 656 + ], + "spans": [ + { + "bbox": [ + 126, + 642, + 333, + 656 + ], + "score": 1.0, + "content": "neural scaling laws. CoRR, abs/2102.06701, 2021.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 658, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 506, + 672 + ], + "score": 1.0, + "content": "[24] Jonathan S. Rosenfeld. Scaling Laws for Deep Learning. PhD thesis, Massachusetts Institute of", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 669, + 229, + 683 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 229, + 683 + ], + "score": 1.0, + "content": "Technology, USA, 2021.", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 684, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 106, + 684, + 506, + 698 + ], + "score": 1.0, + "content": "[25] A Engel and C V den Broeck. Statistical Mechanics of Learning. Cambridge Univ. Press, 2001.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "[26] Madhu Advani, Subhaneil Lahiri, and Surya Ganguli. Statistical mechanics of complex neural", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 125, + 710, + 486, + 726 + ], + "spans": [ + { + "bbox": [ + 125, + 710, + 486, + 726 + ], + "score": 1.0, + "content": "systems and high dimensional data. J. Stat. Mech: Theory Exp., 2013(03):P03014, 2013.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 25 + } + ], + "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": "list", + "bbox": [ + 105, + 51, + 507, + 725 + ], + "lines": [], + "index": 25, + "bbox_fs": [ + 104, + 71, + 507, + 726 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 46, + 507, + 726 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 507, + 87 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 507, + 87 + ], + "score": 1.0, + "content": "[27] Yasaman Bahri, Jonathan Kadmon, Jeffrey Pennington, Sam S Schoenholz, Jascha Sohl-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 83, + 506, + 98 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 98 + ], + "score": 1.0, + "content": "Dickstein, and Surya Ganguli. Statistical mechanics of deep learning. Annual Review of", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 94, + 293, + 108 + ], + "spans": [ + { + "bbox": [ + 127, + 94, + 293, + 108 + ], + "score": 1.0, + "content": "Condensed Matter Physics, March 2020.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 106, + 111, + 505, + 123 + ], + "score": 1.0, + "content": "[28] Lenka Zdeborová and Florent Krzakala. Statistical physics of inference: thresholds and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 127, + 121, + 359, + 135 + ], + "spans": [ + { + "bbox": [ + 127, + 121, + 359, + 135 + ], + "score": 1.0, + "content": "algorithms. Adv. Phys., 65(5):453–552, September 2016.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 151 + ], + "score": 1.0, + "content": "[29] E Gardner. The space of interactions in neural network models. J. of Physics A, 21:257–270,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 149, + 154, + 161 + ], + "spans": [ + { + "bbox": [ + 127, + 149, + 154, + 161 + ], + "score": 1.0, + "content": "1988.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "[30] H S Seung, H Sompolinsky, and N Tishby. Statistical mechanics of learning from examples.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 176, + 257, + 188 + ], + "spans": [ + { + "bbox": [ + 127, + 176, + 257, + 188 + ], + "score": 1.0, + "content": "Phys. Rev. A, 45(8):6056, 1992.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 191, + 506, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 506, + 205 + ], + "score": 1.0, + "content": "[31] Yoav Freund, H Sebastian Seung, Eli Shamir, and Naftali Tishby. Information, prediction, and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 202, + 374, + 216 + ], + "spans": [ + { + "bbox": [ + 127, + 202, + 374, + 216 + ], + "score": 1.0, + "content": "query by committee. Adv. Neural Inf. Process. Syst., 5, 1992.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 216, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 234 + ], + "score": 1.0, + "content": "[32] Hai-Jun Zhou. Active online learning in the binary perceptron problem. Commun. Theor. Phys.,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 229, + 236, + 243 + ], + "spans": [ + { + "bbox": [ + 127, + 229, + 236, + 243 + ], + "score": 1.0, + "content": "71(2):243, February 2019.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 259 + ], + "score": 1.0, + "content": "[33] Hugo Cui, Luca Saglietti, and Lenka Zdeborovà. Large deviations in the perceptron model and", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 256, + 289, + 270 + ], + "spans": [ + { + "bbox": [ + 126, + 256, + 289, + 270 + ], + "score": 1.0, + "content": "consequences for active learning, 2021.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 272, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 506, + 286 + ], + "score": 1.0, + "content": "[34] M Mezard, G Parisi, and M A Virasoro. Spin glass theory and beyond. World scientific", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 284, + 200, + 297 + ], + "spans": [ + { + "bbox": [ + 126, + 284, + 200, + 297 + ], + "score": 1.0, + "content": "Singapore, 1987.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 298, + 507, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 507, + 312 + ], + "score": 1.0, + "content": "[35] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 311, + 506, + 323 + ], + "spans": [ + { + "bbox": [ + 127, + 311, + 506, + 323 + ], + "score": 1.0, + "content": "Unsupervised learning of visual features by contrasting cluster assignments. In H. Larochelle,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 125, + 319, + 507, + 336 + ], + "spans": [ + { + "bbox": [ + 125, + 319, + 507, + 336 + ], + "score": 1.0, + "content": "M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin, editors, Advances in Neural Information", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 332, + 456, + 346 + ], + "spans": [ + { + "bbox": [ + 127, + 332, + 456, + 346 + ], + "score": 1.0, + "content": "Processing Systems, volume 33, pages 9912–9924. Curran Associates, Inc., 2020.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 506, + 362 + ], + "score": 1.0, + "content": "[36] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 127, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 125, + 368, + 507, + 386 + ], + "spans": [ + { + "bbox": [ + 125, + 368, + 507, + 386 + ], + "score": 1.0, + "content": "models from natural language supervision. In International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 381, + 261, + 393 + ], + "spans": [ + { + "bbox": [ + 126, + 381, + 261, + 393 + ], + "score": 1.0, + "content": "pages 8748–8763. PMLR, 2021.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 398, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 506, + 410 + ], + "score": 1.0, + "content": "[37] Dhruv Mahajan, Ross Girshick, Vignesh Ramanathan, Kaiming He, Manohar Paluri, Yixuan Li,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 407, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 127, + 407, + 506, + 421 + ], + "score": 1.0, + "content": "Ashwin Bharambe, and Laurens Van Der Maaten. Exploring the limits of weakly supervised", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 419, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 126, + 419, + 506, + 433 + ], + "score": 1.0, + "content": "pretraining. In Proceedings of the European conference on computer vision (ECCV), pages", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 429, + 193, + 443 + ], + "spans": [ + { + "bbox": [ + 127, + 429, + 193, + 443 + ], + "score": 1.0, + "content": "181–196, 2018.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 459 + ], + "score": 1.0, + "content": "[38] Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 456, + 497, + 471 + ], + "spans": [ + { + "bbox": [ + 126, + 456, + 497, + 471 + ], + "score": 1.0, + "content": "text-conditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 472, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 506, + 486 + ], + "score": 1.0, + "content": "[39] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 483, + 507, + 497 + ], + "spans": [ + { + "bbox": [ + 127, + 483, + 507, + 497 + ], + "score": 1.0, + "content": "Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm:", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 495, + 465, + 509 + ], + "spans": [ + { + "bbox": [ + 127, + 495, + 465, + 509 + ], + "score": 1.0, + "content": "Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "[40] Priya Goyal, Quentin Duval, Jeremy Reizenstein, Matthew Leavitt, Min Xu, Benjamin", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 126, + 520, + 507, + 536 + ], + "spans": [ + { + "bbox": [ + 126, + 520, + 507, + 536 + ], + "score": 1.0, + "content": "Lefaudeux, Mannat Singh, Vinicius Reis, Mathilde Caron, Piotr Bojanowski, Armand Joulin,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 532, + 476, + 546 + ], + "spans": [ + { + "bbox": [ + 127, + 532, + 476, + 546 + ], + "score": 1.0, + "content": "and Ishan Misra. VISSL. https://github.com/facebookresearch/vissl, 2021.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 547, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 563 + ], + "score": 1.0, + "content": "[41] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 127, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 126, + 570, + 485, + 583 + ], + "spans": [ + { + "bbox": [ + 126, + 570, + 485, + 583 + ], + "score": 1.0, + "content": "recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 587, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 506, + 599 + ], + "score": 1.0, + "content": "[42] Kaiyu Yang, Klint Qinami, Li Fei-Fei, Jia Deng, and Olga Russakovsky. Towards fairer datasets:", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 597, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 127, + 597, + 506, + 611 + ], + "score": 1.0, + "content": "Filtering and balancing the distribution of the people subtree in the ImageNet hierarchy. In", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 607, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 126, + 607, + 506, + 623 + ], + "score": 1.0, + "content": "Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pages", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 619, + 194, + 631 + ], + "spans": [ + { + "bbox": [ + 127, + 619, + 194, + 631 + ], + "score": 1.0, + "content": "547–558, 2020.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 635, + 507, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 507, + 649 + ], + "score": 1.0, + "content": "[43] Yuki M Asano, Christian Rupprecht, Andrew Zisserman, and Andrea Vedaldi. PASS:", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 127, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "An ImageNet replacement for self-supervised pretraining without humans. arXiv preprint", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 657, + 231, + 669 + ], + "spans": [ + { + "bbox": [ + 127, + 657, + 231, + 669 + ], + "score": 1.0, + "content": "arXiv:2109.13228, 2021.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 673, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 673, + 209, + 685 + ], + "score": 1.0, + "content": "[44] Ross Wightman.", + "type": "text" + }, + { + "bbox": [ + 220, + 673, + 339, + 687 + ], + "score": 1.0, + "content": "Pytorch image models.", + "type": "text" + }, + { + "bbox": [ + 340, + 673, + 506, + 687 + ], + "score": 1.0, + "content": "https://github.com/rwightman/", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 124, + 683, + 264, + 697 + ], + "spans": [ + { + "bbox": [ + 124, + 683, + 264, + 697 + ], + "score": 1.0, + "content": "pytorch-image-models, 2019.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 506, + 714 + ], + "score": 1.0, + "content": "[45] Justin M Johnson and Taghi M Khoshgoftaar. Survey on deep learning with class imbalance.", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 126, + 710, + 282, + 724 + ], + "spans": [ + { + "bbox": [ + 126, + 710, + 282, + 724 + ], + "score": 1.0, + "content": "Journal of Big Data, 6(1):1–54, 2019.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 25 + } + ], + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 46, + 507, + 726 + ], + "lines": [], + "index": 25, + "bbox_fs": [ + 105, + 72, + 507, + 724 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 72, + 507, + 397 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 86 + ], + "score": 1.0, + "content": "[46] Robert Geirhos, Kantharaju Narayanappa, Benjamin Mitzkus, Tizian Thieringer, Matthias", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "Bethge, Felix A Wichmann, and Wieland Brendel. Partial success in closing the gap between", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 506, + 107 + ], + "score": 1.0, + "content": "human and machine vision. Advances in Neural Information Processing Systems, 34:23885–", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 105, + 183, + 118 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 183, + 118 + ], + "score": 1.0, + "content": "23899, 2021.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 120, + 506, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 120, + 506, + 133 + ], + "score": 1.0, + "content": "[47] Felix A Wichmann, David HJ Janssen, Robert Geirhos, Guillermo Aguilar, Heiko H Schütt,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 131, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 127, + 131, + 506, + 144 + ], + "score": 1.0, + "content": "Marianne Maertens, and Matthias Bethge. Methods and measurements to compare men against", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 142, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 127, + 142, + 506, + 155 + ], + "score": 1.0, + "content": "machines. Electronic Imaging, Human Vision and Electronic Imaging, 2017(14):36–45, 2017.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 108, + 158, + 505, + 169 + ], + "spans": [ + { + "bbox": [ + 108, + 158, + 505, + 169 + ], + "score": 1.0, + "content": "[48] Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 167, + 506, + 180 + ], + "spans": [ + { + "bbox": [ + 127, + 167, + 506, + 180 + ], + "score": 1.0, + "content": "Felix A Wichmann. Generalisation in humans and deep neural networks. In Advances in Neural", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 180, + 286, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 180, + 286, + 191 + ], + "score": 1.0, + "content": "Information Processing Systems, 2018.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "[49] Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 204, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 127, + 204, + 506, + 217 + ], + "score": 1.0, + "content": "Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 216, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 127, + 216, + 506, + 229 + ], + "score": 1.0, + "content": "improves accuracy and robustness. In International Conference on Learning Representations,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 226, + 153, + 239 + ], + "spans": [ + { + "bbox": [ + 127, + 226, + 153, + 239 + ], + "score": 1.0, + "content": "2019.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "[50] Haohan Wang, Songwei Ge, Zachary Lipton, and Eric P Xing. Learning robust global repre-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 126, + 252, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 126, + 252, + 506, + 266 + ], + "score": 1.0, + "content": "sentations by penalizing local predictive power. Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 264, + 204, + 275 + ], + "spans": [ + { + "bbox": [ + 127, + 264, + 204, + 275 + ], + "score": 1.0, + "content": "Systems, 32, 2019.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 277, + 507, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 507, + 292 + ], + "score": 1.0, + "content": "[51] Robert Geirhos, Kristof Meding, and Felix A Wichmann. Beyond accuracy: quantifying trial-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 127, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "by-trial behaviour of CNNs and humans by measuring error consistency. Advances in Neural", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 300, + 301, + 313 + ], + "spans": [ + { + "bbox": [ + 127, + 300, + 301, + 313 + ], + "score": 1.0, + "content": "Information Processing Systems, 33, 2020.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 314, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 328 + ], + "score": 1.0, + "content": "[52] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers:", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 127, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Surpassing human-level performance on ImageNet classification. In Proceedings of the IEEE", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 336, + 416, + 350 + ], + "spans": [ + { + "bbox": [ + 127, + 336, + 416, + 350 + ], + "score": 1.0, + "content": "International Conference on Computer Vision, pages 1026–1034, 2015.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "[53] John P Miller, Rohan Taori, Aditi Raghunathan, Shiori Sagawa, Pang Wei Koh, Vaishaal", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 361, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 127, + 361, + 506, + 376 + ], + "score": 1.0, + "content": "Shankar, Percy Liang, Yair Carmon, and Ludwig Schmidt. Accuracy on the line: on the strong", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 127, + 374, + 506, + 387 + ], + "spans": [ + { + "bbox": [ + 127, + 374, + 506, + 387 + ], + "score": 1.0, + "content": "correlation between out-of-distribution and in-distribution generalization. In International", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 384, + 399, + 398 + ], + "spans": [ + { + "bbox": [ + 127, + 384, + 399, + 398 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pages 7721–7735. PMLR, 2021.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 13 + } + ], + "page_idx": 12, + "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": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 72, + 507, + 397 + ], + "lines": [], + "index": 13, + "bbox_fs": [ + 105, + 73, + 507, + 398 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 156, + 84 + ], + "lines": [ + { + "bbox": [ + 106, + 70, + 158, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 158, + 85 + ], + "score": 1.0, + "content": "Checklist", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 131, + 92, + 208, + 104 + ], + "lines": [ + { + "bbox": [ + 129, + 91, + 210, + 105 + ], + "spans": [ + { + "bbox": [ + 129, + 91, + 210, + 105 + ], + "score": 1.0, + "content": "1. For all authors...", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 146, + 107, + 505, + 190 + ], + "lines": [ + { + "bbox": [ + 145, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 145, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 162, + 118, + 288, + 131 + ], + "spans": [ + { + "bbox": [ + 162, + 118, + 288, + 131 + ], + "score": 1.0, + "content": "contributions and scope? [Yes]", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 145, + 131, + 477, + 143 + ], + "spans": [ + { + "bbox": [ + 145, + 131, + 477, + 143 + ], + "score": 1.0, + "content": "(b) Did you describe the limitations of your work? [Yes] See discussion section 7.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 145, + 144, + 506, + 157 + ], + "spans": [ + { + "bbox": [ + 145, + 144, + 506, + 157 + ], + "score": 1.0, + "content": "(c) Did you discuss any potential negative societal impacts of your work? [Yes] See", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 162, + 155, + 292, + 167 + ], + "spans": [ + { + "bbox": [ + 162, + 155, + 292, + 167 + ], + "score": 1.0, + "content": "discussion section 7 and App. I.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 145, + 167, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 145, + 167, + 505, + 180 + ], + "score": 1.0, + "content": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 161, + 178, + 214, + 191 + ], + "spans": [ + { + "bbox": [ + 161, + 178, + 214, + 191 + ], + "score": 1.0, + "content": "them? [Yes]", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 131, + 193, + 302, + 205 + ], + "lines": [ + { + "bbox": [ + 129, + 192, + 304, + 207 + ], + "spans": [ + { + "bbox": [ + 129, + 192, + 304, + 207 + ], + "score": 1.0, + "content": "2. If you are including theoretical results...", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 146, + 208, + 499, + 233 + ], + "lines": [ + { + "bbox": [ + 145, + 208, + 499, + 222 + ], + "spans": [ + { + "bbox": [ + 145, + 208, + 499, + 222 + ], + "score": 1.0, + "content": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See App. A", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 145, + 221, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 145, + 221, + 470, + 234 + ], + "score": 1.0, + "content": "(b) Did you include complete proofs of all theoretical results? [Yes] See App. A", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 130, + 237, + 241, + 248 + ], + "lines": [ + { + "bbox": [ + 128, + 235, + 243, + 250 + ], + "spans": [ + { + "bbox": [ + 128, + 235, + 243, + 250 + ], + "score": 1.0, + "content": "3. If you ran experiments...", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 144, + 251, + 505, + 400 + ], + "lines": [ + { + "bbox": [ + 146, + 251, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 146, + 251, + 506, + 264 + ], + "score": 1.0, + "content": "(a) Did you include the code, data, and instructions needed to reproduce the main exper-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 161, + 261, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 161, + 261, + 506, + 275 + ], + "score": 1.0, + "content": "imental results (either in the supplemental material or as a URL)? [No] All code for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 162, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 162, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "theory plots and numerical perceptron simulations is packaged in a reproducible colab", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 162, + 284, + 204, + 295 + ], + "spans": [ + { + "bbox": [ + 162, + 284, + 204, + 295 + ], + "score": 1.0, + "content": "notebook.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 146, + 296, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 146, + 296, + 505, + 310 + ], + "score": 1.0, + "content": "(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 161, + 307, + 296, + 320 + ], + "spans": [ + { + "bbox": [ + 161, + 307, + 296, + 320 + ], + "score": 1.0, + "content": "were chosen)? [Yes] See App. B.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 147, + 321, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 147, + 322, + 160, + 333 + ], + "score": 1.0, + "content": "(c)", + "type": "text" + }, + { + "bbox": [ + 161, + 321, + 506, + 333 + ], + "score": 1.0, + "content": "Did you report error bars (e.g., with respect to the random seed after running experi-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 161, + 331, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 161, + 331, + 506, + 344 + ], + "score": 1.0, + "content": "ments multiple times)? [No] Since we train a very large (order 100) number of models", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 161, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 161, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "on computationally intensive tasks (e.g. ImageNet), many of our plots contain only", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 162, + 354, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 162, + 354, + 505, + 366 + ], + "score": 1.0, + "content": "results from a single random seed. However, variability due to random seeds can be", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 161, + 363, + 452, + 377 + ], + "spans": [ + { + "bbox": [ + 161, + 363, + 452, + 377 + ], + "score": 1.0, + "content": "inferred by the smooth progression of the relevant quantity on each plot.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 147, + 376, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 147, + 376, + 505, + 391 + ], + "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": 24 + }, + { + "bbox": [ + 161, + 387, + 417, + 401 + ], + "spans": [ + { + "bbox": [ + 161, + 387, + 417, + 401 + ], + "score": 1.0, + "content": "of GPUs, internal cluster, or cloud provider)? [Yes] See App. B", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 130, + 403, + 504, + 415 + ], + "lines": [ + { + "bbox": [ + 128, + 401, + 507, + 417 + ], + "spans": [ + { + "bbox": [ + 128, + 401, + 507, + 417 + ], + "score": 1.0, + "content": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 146, + 417, + 504, + 503 + ], + "lines": [ + { + "bbox": [ + 145, + 417, + 424, + 430 + ], + "spans": [ + { + "bbox": [ + 145, + 417, + 424, + 430 + ], + "score": 1.0, + "content": "(a) If your work uses existing assets, did you cite the creators? [Yes]", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 145, + 430, + 405, + 443 + ], + "spans": [ + { + "bbox": [ + 145, + 430, + 405, + 443 + ], + "score": 1.0, + "content": "(b) Did you mention the license of the assets? [Yes] See App. B", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 144, + 442, + 503, + 457 + ], + "spans": [ + { + "bbox": [ + 144, + 442, + 503, + 457 + ], + "score": 1.0, + "content": "(c) Did you include any new assets either in the supplemental material or as a URL? [No]", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 146, + 457, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 146, + 457, + 505, + 469 + ], + "score": 1.0, + "content": "(d) Did you discuss whether and how consent was obtained from people whose data you’re", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 161, + 467, + 299, + 479 + ], + "spans": [ + { + "bbox": [ + 161, + 467, + 299, + 479 + ], + "score": 1.0, + "content": "using/curating? [Yes] See App. B", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 146, + 480, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 146, + 480, + 505, + 493 + ], + "score": 1.0, + "content": "(e) Did you discuss whether the data you are using/curating contains personally identifiable", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 162, + 491, + 370, + 504 + ], + "spans": [ + { + "bbox": [ + 162, + 491, + 370, + 504 + ], + "score": 1.0, + "content": "information or offensive content? [Yes] See App. B", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 131, + 506, + 432, + 518 + ], + "lines": [ + { + "bbox": [ + 128, + 504, + 433, + 520 + ], + "spans": [ + { + "bbox": [ + 128, + 504, + 433, + 520 + ], + "score": 1.0, + "content": "5. If you used crowdsourcing or conducted research with human subjects...", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 146, + 521, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 145, + 520, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 145, + 520, + 506, + 534 + ], + "score": 1.0, + "content": "(a) Did you include the full text of instructions given to participants and screenshots, if", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 161, + 532, + 237, + 544 + ], + "spans": [ + { + "bbox": [ + 161, + 532, + 237, + 544 + ], + "score": 1.0, + "content": "applicable? [N/A]", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 145, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 145, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "(b) Did you describe any potential participant risks, with links to Institutional Review", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 162, + 555, + 342, + 568 + ], + "spans": [ + { + "bbox": [ + 162, + 555, + 342, + 568 + ], + "score": 1.0, + "content": "Board (IRB) approvals, if applicable? [N/A]", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 146, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 146, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "(c) Did you include the estimated hourly wage paid to participants and the total amount", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 161, + 580, + 333, + 592 + ], + "spans": [ + { + "bbox": [ + 161, + 580, + 333, + 592 + ], + "score": 1.0, + "content": "spent on participant compensation? [N/A]", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5 + } + ], + "page_idx": 13, + "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": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 71, + 156, + 84 + ], + "lines": [ + { + "bbox": [ + 106, + 70, + 158, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 70, + 158, + 85 + ], + "score": 1.0, + "content": "Checklist", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 131, + 92, + 208, + 104 + ], + "lines": [ + { + "bbox": [ + 129, + 91, + 210, + 105 + ], + "spans": [ + { + "bbox": [ + 129, + 91, + 210, + 105 + ], + "score": 1.0, + "content": "1. For all authors...", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1, + "bbox_fs": [ + 129, + 91, + 210, + 105 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 107, + 505, + 190 + ], + "lines": [ + { + "bbox": [ + 145, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 145, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 118, + 288, + 131 + ], + "spans": [ + { + "bbox": [ + 162, + 118, + 288, + 131 + ], + "score": 1.0, + "content": "contributions and scope? [Yes]", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 131, + 477, + 143 + ], + "spans": [ + { + "bbox": [ + 145, + 131, + 477, + 143 + ], + "score": 1.0, + "content": "(b) Did you describe the limitations of your work? [Yes] See discussion section 7.", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 144, + 506, + 157 + ], + "spans": [ + { + "bbox": [ + 145, + 144, + 506, + 157 + ], + "score": 1.0, + "content": "(c) Did you discuss any potential negative societal impacts of your work? [Yes] See", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 155, + 292, + 167 + ], + "spans": [ + { + "bbox": [ + 162, + 155, + 292, + 167 + ], + "score": 1.0, + "content": "discussion section 7 and App. I.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 167, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 145, + 167, + 505, + 180 + ], + "score": 1.0, + "content": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 178, + 214, + 191 + ], + "spans": [ + { + "bbox": [ + 161, + 178, + 214, + 191 + ], + "score": 1.0, + "content": "them? [Yes]", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + } + ], + "index": 5, + "bbox_fs": [ + 145, + 106, + 506, + 191 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 193, + 302, + 205 + ], + "lines": [ + { + "bbox": [ + 129, + 192, + 304, + 207 + ], + "spans": [ + { + "bbox": [ + 129, + 192, + 304, + 207 + ], + "score": 1.0, + "content": "2. If you are including theoretical results...", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9, + "bbox_fs": [ + 129, + 192, + 304, + 207 + ] + }, + { + "type": "text", + "bbox": [ + 146, + 208, + 499, + 233 + ], + "lines": [ + { + "bbox": [ + 145, + 208, + 499, + 222 + ], + "spans": [ + { + "bbox": [ + 145, + 208, + 499, + 222 + ], + "score": 1.0, + "content": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See App. A", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 145, + 221, + 470, + 234 + ], + "spans": [ + { + "bbox": [ + 145, + 221, + 470, + 234 + ], + "score": 1.0, + "content": "(b) Did you include complete proofs of all theoretical results? [Yes] See App. A", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 145, + 208, + 499, + 234 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 237, + 241, + 248 + ], + "lines": [ + { + "bbox": [ + 128, + 235, + 243, + 250 + ], + "spans": [ + { + "bbox": [ + 128, + 235, + 243, + 250 + ], + "score": 1.0, + "content": "3. If you ran experiments...", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 128, + 235, + 243, + 250 + ] + }, + { + "type": "list", + "bbox": [ + 144, + 251, + 505, + 400 + ], + "lines": [ + { + "bbox": [ + 146, + 251, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 146, + 251, + 506, + 264 + ], + "score": 1.0, + "content": "(a) Did you include the code, data, and instructions needed to reproduce the main exper-", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 261, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 161, + 261, + 506, + 275 + ], + "score": 1.0, + "content": "imental results (either in the supplemental material or as a URL)? [No] All code for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 162, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 162, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "theory plots and numerical perceptron simulations is packaged in a reproducible colab", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 162, + 284, + 204, + 295 + ], + "spans": [ + { + "bbox": [ + 162, + 284, + 204, + 295 + ], + "score": 1.0, + "content": "notebook.", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 296, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 146, + 296, + 505, + 310 + ], + "score": 1.0, + "content": "(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 307, + 296, + 320 + ], + "spans": [ + { + "bbox": [ + 161, + 307, + 296, + 320 + ], + "score": 1.0, + "content": "were chosen)? [Yes] See App. B.", + "type": "text" + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 147, + 321, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 147, + 322, + 160, + 333 + ], + "score": 1.0, + "content": "(c)", + "type": "text" + }, + { + "bbox": [ + 161, + 321, + 506, + 333 + ], + "score": 1.0, + "content": "Did you report error bars (e.g., with respect to the random seed after running experi-", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 331, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 161, + 331, + 506, + 344 + ], + "score": 1.0, + "content": "ments multiple times)? [No] Since we train a very large (order 100) number of models", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 161, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 161, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "on computationally intensive tasks (e.g. ImageNet), many of our plots contain only", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 162, + 354, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 162, + 354, + 505, + 366 + ], + "score": 1.0, + "content": "results from a single random seed. However, variability due to random seeds can be", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 161, + 363, + 452, + 377 + ], + "spans": [ + { + "bbox": [ + 161, + 363, + 452, + 377 + ], + "score": 1.0, + "content": "inferred by the smooth progression of the relevant quantity on each plot.", + "type": "text" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 147, + 376, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 147, + 376, + 505, + 391 + ], + "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": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 387, + 417, + 401 + ], + "spans": [ + { + "bbox": [ + 161, + 387, + 417, + 401 + ], + "score": 1.0, + "content": "of GPUs, internal cluster, or cloud provider)? [Yes] See App. B", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + } + ], + "index": 19, + "bbox_fs": [ + 146, + 251, + 506, + 401 + ] + }, + { + "type": "text", + "bbox": [ + 130, + 403, + 504, + 415 + ], + "lines": [ + { + "bbox": [ + 128, + 401, + 507, + 417 + ], + "spans": [ + { + "bbox": [ + 128, + 401, + 507, + 417 + ], + "score": 1.0, + "content": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26, + "bbox_fs": [ + 128, + 401, + 507, + 417 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 417, + 504, + 503 + ], + "lines": [ + { + "bbox": [ + 145, + 417, + 424, + 430 + ], + "spans": [ + { + "bbox": [ + 145, + 417, + 424, + 430 + ], + "score": 1.0, + "content": "(a) If your work uses existing assets, did you cite the creators? [Yes]", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 430, + 405, + 443 + ], + "spans": [ + { + "bbox": [ + 145, + 430, + 405, + 443 + ], + "score": 1.0, + "content": "(b) Did you mention the license of the assets? [Yes] See App. B", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 144, + 442, + 503, + 457 + ], + "spans": [ + { + "bbox": [ + 144, + 442, + 503, + 457 + ], + "score": 1.0, + "content": "(c) Did you include any new assets either in the supplemental material or as a URL? [No]", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 146, + 457, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 146, + 457, + 505, + 469 + ], + "score": 1.0, + "content": "(d) Did you discuss whether and how consent was obtained from people whose data you’re", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 467, + 299, + 479 + ], + "spans": [ + { + "bbox": [ + 161, + 467, + 299, + 479 + ], + "score": 1.0, + "content": "using/curating? [Yes] See App. B", + "type": "text" + } + ], + "index": 31, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 480, + 505, + 493 + ], + "spans": [ + { + "bbox": [ + 146, + 480, + 505, + 493 + ], + "score": 1.0, + "content": "(e) Did you discuss whether the data you are using/curating contains personally identifiable", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 491, + 370, + 504 + ], + "spans": [ + { + "bbox": [ + 162, + 491, + 370, + 504 + ], + "score": 1.0, + "content": "information or offensive content? [Yes] See App. B", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + } + ], + "index": 30, + "bbox_fs": [ + 144, + 417, + 505, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 506, + 432, + 518 + ], + "lines": [ + { + "bbox": [ + 128, + 504, + 433, + 520 + ], + "spans": [ + { + "bbox": [ + 128, + 504, + 433, + 520 + ], + "score": 1.0, + "content": "5. If you used crowdsourcing or conducted research with human subjects...", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34, + "bbox_fs": [ + 128, + 504, + 433, + 520 + ] + }, + { + "type": "list", + "bbox": [ + 146, + 521, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 145, + 520, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 145, + 520, + 506, + 534 + ], + "score": 1.0, + "content": "(a) Did you include the full text of instructions given to participants and screenshots, if", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 532, + 237, + 544 + ], + "spans": [ + { + "bbox": [ + 161, + 532, + 237, + 544 + ], + "score": 1.0, + "content": "applicable? [N/A]", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 145, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 145, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "(b) Did you describe any potential participant risks, with links to Institutional Review", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 162, + 555, + 342, + 568 + ], + "spans": [ + { + "bbox": [ + 162, + 555, + 342, + 568 + ], + "score": 1.0, + "content": "Board (IRB) approvals, if applicable? [N/A]", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 146, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 146, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "(c) Did you include the estimated hourly wage paid to participants and the total amount", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 161, + 580, + 333, + 592 + ], + "spans": [ + { + "bbox": [ + 161, + 580, + 333, + 592 + ], + "score": 1.0, + "content": "spent on participant compensation? [N/A]", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + } + ], + "index": 37.5, + "bbox_fs": [ + 145, + 520, + 506, + 592 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file