diff --git "a/parse/dev/CZZFRxbOLC/CZZFRxbOLC_middle.json" "b/parse/dev/CZZFRxbOLC/CZZFRxbOLC_middle.json" new file mode 100644--- /dev/null +++ "b/parse/dev/CZZFRxbOLC/CZZFRxbOLC_middle.json" @@ -0,0 +1,43052 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 180, + 98, + 430, + 137 + ], + "lines": [ + { + "bbox": [ + 178, + 96, + 431, + 118 + ], + "spans": [ + { + "bbox": [ + 178, + 96, + 431, + 118 + ], + "score": 1.0, + "content": "Patching open-vocabulary models", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 214, + 117, + 397, + 139 + ], + "spans": [ + { + "bbox": [ + 214, + 117, + 397, + 139 + ], + "score": 1.0, + "content": "by interpolating weights", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 124, + 178, + 487, + 213 + ], + "lines": [ + { + "bbox": [ + 123, + 178, + 488, + 191 + ], + "spans": [ + { + "bbox": [ + 123, + 179, + 200, + 190 + ], + "score": 1.0, + "content": "Gabriel Ilharco∗1", + "type": "text" + }, + { + "bbox": [ + 208, + 178, + 304, + 190 + ], + "score": 1.0, + "content": "Mitchell Wortsman∗1", + "type": "text" + }, + { + "bbox": [ + 312, + 178, + 416, + 190 + ], + "score": 1.0, + "content": "Samir Yitzhak Gadre∗2", + "type": "text" + }, + { + "bbox": [ + 424, + 178, + 488, + 191 + ], + "score": 1.0, + "content": "Shuran Song2", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 134, + 189, + 487, + 203 + ], + "spans": [ + { + "bbox": [ + 134, + 190, + 238, + 202 + ], + "score": 1.0, + "content": "Hannaneh Hajishirzi1,3", + "type": "text" + }, + { + "bbox": [ + 246, + 189, + 487, + 203 + ], + "score": 1.0, + "content": "Simon Kornblith4 Ali Farhadi1 Ludwig Schmidt1,3", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 124, + 200, + 482, + 215 + ], + "spans": [ + { + "bbox": [ + 124, + 200, + 482, + 215 + ], + "score": 1.0, + "content": "1University of Washington 2Columbia University 3AI2 4Google Research, Brain Team", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 283, + 242, + 328, + 255 + ], + "lines": [ + { + "bbox": [ + 281, + 241, + 330, + 257 + ], + "spans": [ + { + "bbox": [ + 281, + 241, + 330, + 257 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 262, + 469, + 447 + ], + "lines": [ + { + "bbox": [ + 142, + 262, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 142, + 262, + 469, + 276 + ], + "score": 1.0, + "content": "Open-vocabulary models like CLIP achieve high accuracy across many image", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 273, + 469, + 285 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 469, + 285 + ], + "score": 1.0, + "content": "classification tasks. However, there are still settings where their zero-shot perfor-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 284, + 469, + 297 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 469, + 297 + ], + "score": 1.0, + "content": "mance is far from optimal. We study model patching, where the goal is to improve", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 295, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 470, + 308 + ], + "score": 1.0, + "content": "accuracy on specific tasks without degrading accuracy on tasks where performance", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 140, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 140, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "is already adequate. Towards this goal, we introduce PAINT, a patching method", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "score": 1.0, + "content": "that uses interpolations between the weights of a model before fine-tuning and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 142, + 328, + 470, + 339 + ], + "spans": [ + { + "bbox": [ + 142, + 328, + 470, + 339 + ], + "score": 1.0, + "content": "the weights after fine-tuning on a task to be patched. On nine tasks where zero-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 338, + 469, + 352 + ], + "spans": [ + { + "bbox": [ + 141, + 338, + 469, + 352 + ], + "score": 1.0, + "content": "shot CLIP performs poorly, PAINT increases accuracy by 15 to 60 percentage", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "score": 1.0, + "content": "points while preserving accuracy on ImageNet within one percentage point of the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 359, + 469, + 373 + ], + "spans": [ + { + "bbox": [ + 141, + 359, + 469, + 373 + ], + "score": 1.0, + "content": "zero-shot model. PAINT also allows a single model to be patched on multiple", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 371, + 469, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 371, + 469, + 383 + ], + "score": 1.0, + "content": "tasks and improves with model scale. Furthermore, we identify cases of broad", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 383, + 469, + 394 + ], + "spans": [ + { + "bbox": [ + 141, + 383, + 469, + 394 + ], + "score": 1.0, + "content": "transfer, where patching on one task increases accuracy on other tasks even when", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 393, + 469, + 405 + ], + "spans": [ + { + "bbox": [ + 141, + 393, + 469, + 405 + ], + "score": 1.0, + "content": "the tasks have disjoint classes. Finally, we investigate applications beyond common", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 404, + 469, + 416 + ], + "spans": [ + { + "bbox": [ + 141, + 404, + 469, + 416 + ], + "score": 1.0, + "content": "benchmarks such as counting or reducing the impact of typographic attacks on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 414, + 469, + 428 + ], + "spans": [ + { + "bbox": [ + 141, + 414, + 469, + 428 + ], + "score": 1.0, + "content": "CLIP. Our findings demonstrate that it is possible to expand the set of tasks on", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 425, + 469, + 439 + ], + "spans": [ + { + "bbox": [ + 141, + 425, + 469, + 439 + ], + "score": 1.0, + "content": "which open-vocabulary models achieve high accuracy without re-training them", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 142, + 437, + 196, + 447 + ], + "spans": [ + { + "bbox": [ + 142, + 437, + 196, + 447 + ], + "score": 1.0, + "content": "from scratch.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 107, + 459, + 190, + 472 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 192, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 192, + 474 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "Open-vocabulary models are characterized by their ability to perform any image classification task", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "based on text descriptions of the classes [56]. Thanks to advances in large-scale pre-training, recent", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 499, + 506, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 506, + 512 + ], + "score": 1.0, + "content": "examples of open-vocabulary models such as CLIP and BASIC have reached parity with or surpassed", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 511, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 522 + ], + "score": 1.0, + "content": "important task-specific baselines, even when the open-vocabulary models are not fine-tuned on", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "task-specific data (i.e., in a zero-shot setting) [57, 31, 56, 88, 1, 86]. For instance, the largest CLIP", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "model from Radford et al. [57] used in a zero-shot setting matches the ImageNet accuracy of a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 543, + 350, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 350, + 556 + ], + "score": 1.0, + "content": "ResNet-50 trained on 1.2 million ImageNet images [14, 24].", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 108, + 560, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Nevertheless, current open-vocabulary models still face challenges. The same CLIP model that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "matches a ResNet-50 on ImageNet has lower MNIST accuracy than simple logistic regression in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "pixel space [57]. Moreover, even when zero-shot models achieve good performance, they are usually", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 592, + 405, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 405, + 604 + ], + "score": 1.0, + "content": "still worse than models trained or fine-tuned on specific downstream tasks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 609, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 609, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 506, + 621 + ], + "score": 1.0, + "content": "To address these issues, several authors have proposed methods for adapting zero-shot models to a task", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "score": 1.0, + "content": "of interest using labeled data [82, 91, 21, 89, 37, 73]. A common practice is to fine-tune the zero-shot", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "score": 1.0, + "content": "model on the task of interest [82, 56]. However, fine-tuned models can suffer from catastrophic", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 642, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 654 + ], + "score": 1.0, + "content": "forgetting [48, 76, 20, 33], performing poorly on tasks where the zero-shot model initially performed", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 652, + 506, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 506, + 665 + ], + "score": 1.0, + "content": "well [2, 82, 56]. Additionally, fine-tuning typically produces a task-specific classification head,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 664, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 676 + ], + "score": 1.0, + "content": "sacrificing the flexible text-based API that makes open-vocabulary models so appealing. Whereas", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 675, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 686 + ], + "score": 1.0, + "content": "an open-vocabulary model can perform any classification task in a zero-shot fashion, a fine-tuned", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 693, + 503, + 713 + ], + "lines": [ + { + "bbox": [ + 118, + 691, + 505, + 705 + ], + "spans": [ + { + "bbox": [ + 118, + 691, + 505, + 705 + ], + "score": 1.0, + "content": "∗Equal contribution. Code available at https://github.com/mlfoundations/patching. Correspon-", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 703, + 430, + 714 + ], + "spans": [ + { + "bbox": [ + 106, + 703, + 430, + 714 + ], + "score": 1.0, + "content": "dance to {gamaga,mitchnw,schmidt}@cs.washington.edu, sy@cs.columbia.edu.", + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 180, + 98, + 430, + 137 + ], + "lines": [ + { + "bbox": [ + 178, + 96, + 431, + 118 + ], + "spans": [ + { + "bbox": [ + 178, + 96, + 431, + 118 + ], + "score": 1.0, + "content": "Patching open-vocabulary models", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 214, + 117, + 397, + 139 + ], + "spans": [ + { + "bbox": [ + 214, + 117, + 397, + 139 + ], + "score": 1.0, + "content": "by interpolating weights", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 124, + 178, + 487, + 213 + ], + "lines": [ + { + "bbox": [ + 123, + 178, + 488, + 191 + ], + "spans": [ + { + "bbox": [ + 123, + 179, + 200, + 190 + ], + "score": 1.0, + "content": "Gabriel Ilharco∗1", + "type": "text" + }, + { + "bbox": [ + 208, + 178, + 304, + 190 + ], + "score": 1.0, + "content": "Mitchell Wortsman∗1", + "type": "text" + }, + { + "bbox": [ + 312, + 178, + 416, + 190 + ], + "score": 1.0, + "content": "Samir Yitzhak Gadre∗2", + "type": "text" + }, + { + "bbox": [ + 424, + 178, + 488, + 191 + ], + "score": 1.0, + "content": "Shuran Song2", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 134, + 189, + 487, + 203 + ], + "spans": [ + { + "bbox": [ + 134, + 190, + 238, + 202 + ], + "score": 1.0, + "content": "Hannaneh Hajishirzi1,3", + "type": "text" + }, + { + "bbox": [ + 246, + 189, + 487, + 203 + ], + "score": 1.0, + "content": "Simon Kornblith4 Ali Farhadi1 Ludwig Schmidt1,3", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 124, + 200, + 482, + 215 + ], + "spans": [ + { + "bbox": [ + 124, + 200, + 482, + 215 + ], + "score": 1.0, + "content": "1University of Washington 2Columbia University 3AI2 4Google Research, Brain Team", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 123, + 178, + 488, + 215 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 242, + 328, + 255 + ], + "lines": [ + { + "bbox": [ + 281, + 241, + 330, + 257 + ], + "spans": [ + { + "bbox": [ + 281, + 241, + 330, + 257 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 262, + 469, + 447 + ], + "lines": [ + { + "bbox": [ + 142, + 262, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 142, + 262, + 469, + 276 + ], + "score": 1.0, + "content": "Open-vocabulary models like CLIP achieve high accuracy across many image", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 273, + 469, + 285 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 469, + 285 + ], + "score": 1.0, + "content": "classification tasks. However, there are still settings where their zero-shot perfor-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 284, + 469, + 297 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 469, + 297 + ], + "score": 1.0, + "content": "mance is far from optimal. We study model patching, where the goal is to improve", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 295, + 470, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 470, + 308 + ], + "score": 1.0, + "content": "accuracy on specific tasks without degrading accuracy on tasks where performance", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 140, + 306, + 470, + 318 + ], + "spans": [ + { + "bbox": [ + 140, + 306, + 470, + 318 + ], + "score": 1.0, + "content": "is already adequate. Towards this goal, we introduce PAINT, a patching method", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "score": 1.0, + "content": "that uses interpolations between the weights of a model before fine-tuning and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 142, + 328, + 470, + 339 + ], + "spans": [ + { + "bbox": [ + 142, + 328, + 470, + 339 + ], + "score": 1.0, + "content": "the weights after fine-tuning on a task to be patched. On nine tasks where zero-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 338, + 469, + 352 + ], + "spans": [ + { + "bbox": [ + 141, + 338, + 469, + 352 + ], + "score": 1.0, + "content": "shot CLIP performs poorly, PAINT increases accuracy by 15 to 60 percentage", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 470, + 362 + ], + "score": 1.0, + "content": "points while preserving accuracy on ImageNet within one percentage point of the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 359, + 469, + 373 + ], + "spans": [ + { + "bbox": [ + 141, + 359, + 469, + 373 + ], + "score": 1.0, + "content": "zero-shot model. PAINT also allows a single model to be patched on multiple", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 371, + 469, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 371, + 469, + 383 + ], + "score": 1.0, + "content": "tasks and improves with model scale. Furthermore, we identify cases of broad", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 383, + 469, + 394 + ], + "spans": [ + { + "bbox": [ + 141, + 383, + 469, + 394 + ], + "score": 1.0, + "content": "transfer, where patching on one task increases accuracy on other tasks even when", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 393, + 469, + 405 + ], + "spans": [ + { + "bbox": [ + 141, + 393, + 469, + 405 + ], + "score": 1.0, + "content": "the tasks have disjoint classes. Finally, we investigate applications beyond common", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 404, + 469, + 416 + ], + "spans": [ + { + "bbox": [ + 141, + 404, + 469, + 416 + ], + "score": 1.0, + "content": "benchmarks such as counting or reducing the impact of typographic attacks on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 414, + 469, + 428 + ], + "spans": [ + { + "bbox": [ + 141, + 414, + 469, + 428 + ], + "score": 1.0, + "content": "CLIP. Our findings demonstrate that it is possible to expand the set of tasks on", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 425, + 469, + 439 + ], + "spans": [ + { + "bbox": [ + 141, + 425, + 469, + 439 + ], + "score": 1.0, + "content": "which open-vocabulary models achieve high accuracy without re-training them", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 142, + 437, + 196, + 447 + ], + "spans": [ + { + "bbox": [ + 142, + 437, + 196, + 447 + ], + "score": 1.0, + "content": "from scratch.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 14, + "bbox_fs": [ + 140, + 262, + 470, + 447 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 459, + 190, + 472 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 192, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 192, + 474 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 478, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 490 + ], + "score": 1.0, + "content": "Open-vocabulary models are characterized by their ability to perform any image classification task", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "based on text descriptions of the classes [56]. Thanks to advances in large-scale pre-training, recent", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 499, + 506, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 506, + 512 + ], + "score": 1.0, + "content": "examples of open-vocabulary models such as CLIP and BASIC have reached parity with or surpassed", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 511, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 522 + ], + "score": 1.0, + "content": "important task-specific baselines, even when the open-vocabulary models are not fine-tuned on", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "task-specific data (i.e., in a zero-shot setting) [57, 31, 56, 88, 1, 86]. For instance, the largest CLIP", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "model from Radford et al. [57] used in a zero-shot setting matches the ImageNet accuracy of a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 543, + 350, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 350, + 556 + ], + "score": 1.0, + "content": "ResNet-50 trained on 1.2 million ImageNet images [14, 24].", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 478, + 506, + 556 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 560, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "Nevertheless, current open-vocabulary models still face challenges. The same CLIP model that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "matches a ResNet-50 on ImageNet has lower MNIST accuracy than simple logistic regression in", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "pixel space [57]. Moreover, even when zero-shot models achieve good performance, they are usually", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 592, + 405, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 405, + 604 + ], + "score": 1.0, + "content": "still worse than models trained or fine-tuned on specific downstream tasks.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 560, + 505, + 604 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 609, + 505, + 686 + ], + "lines": [ + { + "bbox": [ + 105, + 609, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 506, + 621 + ], + "score": 1.0, + "content": "To address these issues, several authors have proposed methods for adapting zero-shot models to a task", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "score": 1.0, + "content": "of interest using labeled data [82, 91, 21, 89, 37, 73]. A common practice is to fine-tune the zero-shot", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 505, + 643 + ], + "score": 1.0, + "content": "model on the task of interest [82, 56]. However, fine-tuned models can suffer from catastrophic", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 642, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 654 + ], + "score": 1.0, + "content": "forgetting [48, 76, 20, 33], performing poorly on tasks where the zero-shot model initially performed", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 652, + 506, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 506, + 665 + ], + "score": 1.0, + "content": "well [2, 82, 56]. Additionally, fine-tuning typically produces a task-specific classification head,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 664, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 676 + ], + "score": 1.0, + "content": "sacrificing the flexible text-based API that makes open-vocabulary models so appealing. Whereas", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 675, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 686 + ], + "score": 1.0, + "content": "an open-vocabulary model can perform any classification task in a zero-shot fashion, a fine-tuned", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 283, + 506, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 296 + ], + "score": 1.0, + "content": "model with a task-specific head can only process the specific task that it was fine-tuned on. This", + "type": "text", + "cross_page": true + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "specialization can prevent knowledge obtained by fine-tuning on one task from transferring to other", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 306, + 248, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 248, + 317 + ], + "score": 1.0, + "content": "related tasks with different classes.", + "type": "text", + "cross_page": true + } + ], + "index": 35 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 609, + 506, + 686 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 89, + 292, + 257 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 89, + 292, + 257 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 89, + 292, + 257 + ], + "spans": [ + { + "bbox": [ + 108, + 89, + 292, + 257 + ], + "score": 0.967, + "type": "image", + "image_path": "27454f67282ad59a0cde948bc9974465c3d8f122323b75d055c62f58685f01e7.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 108, + 89, + 292, + 101.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 101.0, + 292, + 113.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 113.0, + 292, + 125.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 108, + 125.0, + 292, + 137.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 108, + 137.0, + 292, + 149.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 149.0, + 292, + 161.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 161.0, + 292, + 173.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 173.0, + 292, + 185.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 185.0, + 292, + 197.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 108, + 197.0, + 292, + 209.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 209.0, + 292, + 221.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 221.0, + 292, + 233.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 108, + 233.0, + 292, + 245.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 108, + 245.0, + 292, + 257.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 300, + 70, + 505, + 259 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 299, + 70, + 506, + 82 + ], + "spans": [ + { + "bbox": [ + 299, + 70, + 506, + 82 + ], + "score": 1.0, + "content": "Figure 1: Patching open-vocabulary models by lin-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 299, + 80, + 506, + 92 + ], + "spans": [ + { + "bbox": [ + 299, + 80, + 506, + 92 + ], + "score": 1.0, + "content": "early interpolating weights. We wish to improve ac-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 299, + 90, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 299, + 90, + 505, + 102 + ], + "score": 1.0, + "content": "curacy on tasks where a model performs poorly (patching", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 299, + 100, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 299, + 100, + 505, + 111 + ], + "score": 1.0, + "content": "tasks), without degrading performance on tasks where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 299, + 110, + 506, + 121 + ], + "spans": [ + { + "bbox": [ + 299, + 110, + 506, + 121 + ], + "score": 1.0, + "content": "accuracy is already adequate (supported tasks). When", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 299, + 120, + 507, + 131 + ], + "spans": [ + { + "bbox": [ + 299, + 120, + 507, + 131 + ], + "score": 1.0, + "content": "interpolating weights of fine-tuned models and zero-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 299, + 130, + 507, + 141 + ], + "spans": [ + { + "bbox": [ + 299, + 130, + 507, + 141 + ], + "score": 1.0, + "content": "shot (unpatched) models, there are intermediate solu-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 299, + 140, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 299, + 140, + 506, + 151 + ], + "score": 1.0, + "content": "tions where accuracy improves on the patching task", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 299, + 150, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 299, + 150, + 505, + 161 + ], + "score": 1.0, + "content": "without reducing accuracy on supported tasks. Results", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 299, + 159, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 299, + 159, + 505, + 171 + ], + "score": 1.0, + "content": "are shown for CLIP models [57], averaged over nine", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 299, + 171, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 299, + 171, + 506, + 181 + ], + "score": 1.0, + "content": "patching tasks (Stanford Cars, DTD, EuroSAT, GTSRB,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 299, + 180, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 299, + 180, + 506, + 191 + ], + "score": 1.0, + "content": "KITTI distance, MNIST, RESISC45, SUN397 and SVHN", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 299, + 189, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 299, + 189, + 506, + 201 + ], + "score": 1.0, + "content": "[35, 11, 25, 71, 22, 39, 7, 12, 84, 53]) and five supported", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 299, + 200, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 299, + 200, + 506, + 211 + ], + "score": 1.0, + "content": "tasks (ImageNet, CIFAR-10, CIFAR-100, STL-10 and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 299, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 299, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "Food101 [14, 36, 12, 5]). We apply PAINT separately", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 299, + 220, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 299, + 220, + 506, + 231 + ], + "score": 1.0, + "content": "on each patching task and average results across experi-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 300, + 230, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 300, + 230, + 505, + 240 + ], + "score": 1.0, + "content": "ments. The dashed lines illustrate vertical movement from", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 299, + 240, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 299, + 240, + 505, + 250 + ], + "score": 1.0, + "content": "the unpatched models and horizontal movement from the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 300, + 250, + 369, + 260 + ], + "spans": [ + { + "bbox": [ + 300, + 250, + 369, + 260 + ], + "score": 1.0, + "content": "fine-tuned models.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 23 + } + ], + "index": 14.75 + }, + { + "type": "text", + "bbox": [ + 107, + 283, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 283, + 506, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 296 + ], + "score": 1.0, + "content": "model with a task-specific head can only process the specific task that it was fine-tuned on. This", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "specialization can prevent knowledge obtained by fine-tuning on one task from transferring to other", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 306, + 248, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 248, + 317 + ], + "score": 1.0, + "content": "related tasks with different classes.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 323, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 335 + ], + "score": 1.0, + "content": "Another approach to adapting zero-shot models would be to add data from the downstream task to", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "the pre-training dataset and train a new open-vocabulary model from scratch. The resulting model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "could still perform any classification task, and zero-shot performance may improve on related tasks.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "However, training large image-text models from scratch can require hundreds of thousands of GPU", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 365, + 446, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 446, + 381 + ], + "score": 1.0, + "content": "hours [57, 56, 86], which makes this approach practically infeasible in most settings.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "In this paper, we study patching open-vocabulary models, where the goal is to increase accuracy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 104, + 396, + 504, + 408 + ], + "spans": [ + { + "bbox": [ + 104, + 396, + 504, + 408 + ], + "score": 1.0, + "content": "on new target tasks while maintaining the flexibility of the model and its accuracy on other tasks.1", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "score": 1.0, + "content": "Patching aims to combine the benefits of fine-tuning and re-training from scratch: improved perfor-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 417, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 104, + 417, + 505, + 431 + ], + "score": 1.0, + "content": "mance on the task of interest, maintaining the flexibility of an open vocabulary, transfer between", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "tasks, and fast adaptation time. Motivated by these goals, we extend existing fine-tuning techniques", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "[82] to open-vocabulary settings, where the class space is not fixed. We introduce Patching with", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "Interpolation (PAINT), a simple, two-step procedure for patching models: first, fine-tune the model on", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "the patching task without introducing any task-specific parameters; then, linearly interpolate between", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "the weights of the model before and after fine-tuning. Linearly interpolating neural network weights", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 483, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 495 + ], + "score": 1.0, + "content": "[52, 19, 54] has been previously used to improve accuracy on a single task [28, 81] or robustness to", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 493, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 508 + ], + "score": 1.0, + "content": "distribution shift [82]. Indeed, averaging network weights has been explored in continual learning", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 505, + 324, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 324, + 517 + ], + "score": 1.0, + "content": "contexts, although for closed-vocabulary models [40].", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 46.5 + }, + { + "type": "text", + "bbox": [ + 107, + 523, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "With PAINT, accuracy can improve on new tasks without degrading accuracy on unrelated tasks, as", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "score": 1.0, + "content": "illustrated in Figure 1. For instance, applying PAINT to a CLIP ViT-L/14 [57] independently on nine", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 542, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 506, + 558 + ], + "score": 1.0, + "content": "image classification tasks [35, 11, 25, 71, 22, 39, 7, 84, 53] improves accuracy by 15 to 60 percentage", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "points compared to the unpatched model, while accuracy on ImageNet [14] decreases by less than", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "one percentage point. We also observe a promising trend: patching becomes more effective with", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 577, + 213, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 213, + 590 + ], + "score": 1.0, + "content": "model scale (Section 4.1).", + "type": "text" + } + ], + "index": 58 + } + ], + "index": 55.5 + }, + { + "type": "text", + "bbox": [ + 107, + 595, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "Beyond single tasks, we show that models can be patched on multiple tasks (Section 5). When patch-", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "ing on nine image classification tasks simultaneously, a single CLIP ViT-L/14 model is competitive", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "with using one specialized model for each task—the average accuracy difference is less than 0.5", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 105, + 629, + 182, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 182, + 640 + ], + "score": 1.0, + "content": "percentage points.", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 60.5 + }, + { + "type": "text", + "bbox": [ + 107, + 646, + 505, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "Moreover, PAINT enables broad transfer (Section 6): accuracy on related tasks can increase, even", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 657, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 669 + ], + "score": 1.0, + "content": "when the class space changes. For instance, we partition EuroSAT [25], a satellite image dataset, into", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 667, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 681 + ], + "score": 1.0, + "content": "two halves with disjoint labels. Patching a ViT-L/14 model on the first half improves accuracy on the", + "type": "text" + } + ], + "index": 65 + }, + { + "bbox": [ + 105, + 679, + 466, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 466, + 692 + ], + "score": 1.0, + "content": "second half by 7.3 percentage points, even though the classes are unseen during patching.", + "type": "text" + } + ], + "index": 66 + } + ], + "index": 64.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 702, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 119, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 119, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "1The term patching is borrowed from software development terminology, drawing inspiration from recent", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 711, + 495, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 495, + 723 + ], + "score": 1.0, + "content": "work which conceptualizes developing machine learning models like open-source software [58, 62, 47, 72].", + "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": [ + 108, + 89, + 292, + 257 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 89, + 292, + 257 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 89, + 292, + 257 + ], + "spans": [ + { + "bbox": [ + 108, + 89, + 292, + 257 + ], + "score": 0.967, + "type": "image", + "image_path": "27454f67282ad59a0cde948bc9974465c3d8f122323b75d055c62f58685f01e7.jpg" + } + ] + } + ], + "index": 6.5, + "virtual_lines": [ + { + "bbox": [ + 108, + 89, + 292, + 101.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 101.0, + 292, + 113.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 113.0, + 292, + 125.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 108, + 125.0, + 292, + 137.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 108, + 137.0, + 292, + 149.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 149.0, + 292, + 161.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 161.0, + 292, + 173.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 108, + 173.0, + 292, + 185.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 108, + 185.0, + 292, + 197.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 108, + 197.0, + 292, + 209.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 108, + 209.0, + 292, + 221.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 108, + 221.0, + 292, + 233.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 108, + 233.0, + 292, + 245.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 108, + 245.0, + 292, + 257.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 300, + 70, + 505, + 259 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 299, + 70, + 506, + 82 + ], + "spans": [ + { + "bbox": [ + 299, + 70, + 506, + 82 + ], + "score": 1.0, + "content": "Figure 1: Patching open-vocabulary models by lin-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 299, + 80, + 506, + 92 + ], + "spans": [ + { + "bbox": [ + 299, + 80, + 506, + 92 + ], + "score": 1.0, + "content": "early interpolating weights. We wish to improve ac-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 299, + 90, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 299, + 90, + 505, + 102 + ], + "score": 1.0, + "content": "curacy on tasks where a model performs poorly (patching", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 299, + 100, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 299, + 100, + 505, + 111 + ], + "score": 1.0, + "content": "tasks), without degrading performance on tasks where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 299, + 110, + 506, + 121 + ], + "spans": [ + { + "bbox": [ + 299, + 110, + 506, + 121 + ], + "score": 1.0, + "content": "accuracy is already adequate (supported tasks). When", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 299, + 120, + 507, + 131 + ], + "spans": [ + { + "bbox": [ + 299, + 120, + 507, + 131 + ], + "score": 1.0, + "content": "interpolating weights of fine-tuned models and zero-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 299, + 130, + 507, + 141 + ], + "spans": [ + { + "bbox": [ + 299, + 130, + 507, + 141 + ], + "score": 1.0, + "content": "shot (unpatched) models, there are intermediate solu-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 299, + 140, + 506, + 151 + ], + "spans": [ + { + "bbox": [ + 299, + 140, + 506, + 151 + ], + "score": 1.0, + "content": "tions where accuracy improves on the patching task", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 299, + 150, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 299, + 150, + 505, + 161 + ], + "score": 1.0, + "content": "without reducing accuracy on supported tasks. Results", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 299, + 159, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 299, + 159, + 505, + 171 + ], + "score": 1.0, + "content": "are shown for CLIP models [57], averaged over nine", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 299, + 171, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 299, + 171, + 506, + 181 + ], + "score": 1.0, + "content": "patching tasks (Stanford Cars, DTD, EuroSAT, GTSRB,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 299, + 180, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 299, + 180, + 506, + 191 + ], + "score": 1.0, + "content": "KITTI distance, MNIST, RESISC45, SUN397 and SVHN", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 299, + 189, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 299, + 189, + 506, + 201 + ], + "score": 1.0, + "content": "[35, 11, 25, 71, 22, 39, 7, 12, 84, 53]) and five supported", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 299, + 200, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 299, + 200, + 506, + 211 + ], + "score": 1.0, + "content": "tasks (ImageNet, CIFAR-10, CIFAR-100, STL-10 and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 299, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 299, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "Food101 [14, 36, 12, 5]). We apply PAINT separately", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 299, + 220, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 299, + 220, + 506, + 231 + ], + "score": 1.0, + "content": "on each patching task and average results across experi-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 300, + 230, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 300, + 230, + 505, + 240 + ], + "score": 1.0, + "content": "ments. The dashed lines illustrate vertical movement from", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 299, + 240, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 299, + 240, + 505, + 250 + ], + "score": 1.0, + "content": "the unpatched models and horizontal movement from the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 300, + 250, + 369, + 260 + ], + "spans": [ + { + "bbox": [ + 300, + 250, + 369, + 260 + ], + "score": 1.0, + "content": "fine-tuned models.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 23 + } + ], + "index": 14.75 + }, + { + "type": "text", + "bbox": [ + 107, + 283, + 505, + 316 + ], + "lines": [], + "index": 34, + "bbox_fs": [ + 105, + 283, + 506, + 317 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 323, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 335 + ], + "score": 1.0, + "content": "Another approach to adapting zero-shot models would be to add data from the downstream task to", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "the pre-training dataset and train a new open-vocabulary model from scratch. The resulting model", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 506, + 358 + ], + "score": 1.0, + "content": "could still perform any classification task, and zero-shot performance may improve on related tasks.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "However, training large image-text models from scratch can require hundreds of thousands of GPU", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 365, + 446, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 446, + 381 + ], + "score": 1.0, + "content": "hours [57, 56, 86], which makes this approach practically infeasible in most settings.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 324, + 506, + 381 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 385, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "In this paper, we study patching open-vocabulary models, where the goal is to increase accuracy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 104, + 396, + 504, + 408 + ], + "spans": [ + { + "bbox": [ + 104, + 396, + 504, + 408 + ], + "score": 1.0, + "content": "on new target tasks while maintaining the flexibility of the model and its accuracy on other tasks.1", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 419 + ], + "score": 1.0, + "content": "Patching aims to combine the benefits of fine-tuning and re-training from scratch: improved perfor-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 417, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 104, + 417, + 505, + 431 + ], + "score": 1.0, + "content": "mance on the task of interest, maintaining the flexibility of an open vocabulary, transfer between", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "tasks, and fast adaptation time. Motivated by these goals, we extend existing fine-tuning techniques", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "[82] to open-vocabulary settings, where the class space is not fixed. We introduce Patching with", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "Interpolation (PAINT), a simple, two-step procedure for patching models: first, fine-tune the model on", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "the patching task without introducing any task-specific parameters; then, linearly interpolate between", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "the weights of the model before and after fine-tuning. Linearly interpolating neural network weights", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 483, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 495 + ], + "score": 1.0, + "content": "[52, 19, 54] has been previously used to improve accuracy on a single task [28, 81] or robustness to", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 493, + 505, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 508 + ], + "score": 1.0, + "content": "distribution shift [82]. Indeed, averaging network weights has been explored in continual learning", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 505, + 324, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 324, + 517 + ], + "score": 1.0, + "content": "contexts, although for closed-vocabulary models [40].", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 46.5, + "bbox_fs": [ + 104, + 385, + 506, + 517 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 523, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "With PAINT, accuracy can improve on new tasks without degrading accuracy on unrelated tasks, as", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "score": 1.0, + "content": "illustrated in Figure 1. For instance, applying PAINT to a CLIP ViT-L/14 [57] independently on nine", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 542, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 542, + 506, + 558 + ], + "score": 1.0, + "content": "image classification tasks [35, 11, 25, 71, 22, 39, 7, 84, 53] improves accuracy by 15 to 60 percentage", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "points compared to the unpatched model, while accuracy on ImageNet [14] decreases by less than", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 505, + 579 + ], + "score": 1.0, + "content": "one percentage point. We also observe a promising trend: patching becomes more effective with", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 577, + 213, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 213, + 590 + ], + "score": 1.0, + "content": "model scale (Section 4.1).", + "type": "text" + } + ], + "index": 58 + } + ], + "index": 55.5, + "bbox_fs": [ + 105, + 522, + 506, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 595, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "Beyond single tasks, we show that models can be patched on multiple tasks (Section 5). When patch-", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "ing on nine image classification tasks simultaneously, a single CLIP ViT-L/14 model is competitive", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "with using one specialized model for each task—the average accuracy difference is less than 0.5", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 105, + 629, + 182, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 182, + 640 + ], + "score": 1.0, + "content": "percentage points.", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 60.5, + "bbox_fs": [ + 105, + 595, + 506, + 640 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 646, + 505, + 690 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "Moreover, PAINT enables broad transfer (Section 6): accuracy on related tasks can increase, even", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 657, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 506, + 669 + ], + "score": 1.0, + "content": "when the class space changes. For instance, we partition EuroSAT [25], a satellite image dataset, into", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 667, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 681 + ], + "score": 1.0, + "content": "two halves with disjoint labels. Patching a ViT-L/14 model on the first half improves accuracy on the", + "type": "text" + } + ], + "index": 65 + }, + { + "bbox": [ + 105, + 679, + 466, + 692 + ], + "spans": [ + { + "bbox": [ + 105, + 679, + 466, + 692 + ], + "score": 1.0, + "content": "second half by 7.3 percentage points, even though the classes are unseen during patching.", + "type": "text" + } + ], + "index": 66 + } + ], + "index": 64.5, + "bbox_fs": [ + 105, + 645, + 506, + 692 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "Finally, we investigate PAINT on case studies including typographic attacks [23], counting [32], and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "visual question answering [4] (Section 7). For instance, applying PAINT using synthetic typographic", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "attacks leads to a model that is less susceptible to typographic attacks in the real world, improving its", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 244, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 244, + 118 + ], + "score": 1.0, + "content": "accuracy by 41 percentage points.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 158, + 133 + ], + "lines": [ + { + "bbox": [ + 106, + 121, + 160, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 160, + 136 + ], + "score": 1.0, + "content": "In summary:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 118, + 138, + 506, + 249 + ], + "lines": [ + { + "bbox": [ + 117, + 139, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 117, + 139, + 505, + 151 + ], + "score": 1.0, + "content": "• Even the best pre-trained models are not perfect. We introduce PAINT, a method designed to", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 126, + 151, + 403, + 163 + ], + "spans": [ + { + "bbox": [ + 126, + 151, + 403, + 163 + ], + "score": 1.0, + "content": "improve accuracy on new tasks without harming accuracy elsewhere.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 117, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 117, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "• PAINT incurs no extra computational cost compared to standard fine-tuning, neither during", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 126, + 175, + 282, + 186 + ], + "spans": [ + { + "bbox": [ + 126, + 175, + 282, + 186 + ], + "score": 1.0, + "content": "fine-tuning itself nor at inference time.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 117, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 117, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "• PAINT can also be applied with multiple tasks, providing a single model that is competitive", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 125, + 199, + 251, + 210 + ], + "spans": [ + { + "bbox": [ + 125, + 199, + 251, + 210 + ], + "score": 1.0, + "content": "with many specialized models.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 211, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 116, + 211, + 506, + 226 + ], + "score": 1.0, + "content": "• Applying PAINT with one task can improve accuracy on a related task, even when they do not", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 125, + 222, + 220, + 235 + ], + "spans": [ + { + "bbox": [ + 125, + 222, + 220, + 235 + ], + "score": 1.0, + "content": "share the same classes.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 117, + 236, + 459, + 249 + ], + "spans": [ + { + "bbox": [ + 117, + 236, + 459, + 249 + ], + "score": 1.0, + "content": "• PAINT improves with model scale, indicating a promising trend for future models.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "title", + "bbox": [ + 106, + 258, + 314, + 272 + ], + "lines": [ + { + "bbox": [ + 104, + 257, + 315, + 275 + ], + "spans": [ + { + "bbox": [ + 104, + 257, + 315, + 275 + ], + "score": 1.0, + "content": "2 Patching with interpolation (PAINT)", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 108, + 277, + 438, + 289 + ], + "lines": [ + { + "bbox": [ + 105, + 276, + 439, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 439, + 291 + ], + "score": 1.0, + "content": "This section details our method for patching models on a single and multiple tasks.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 506, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 411, + 307 + ], + "score": 1.0, + "content": "Patching on a single task. Given an open-vocabulary model with weights", + "type": "text" + }, + { + "bbox": [ + 411, + 295, + 424, + 306 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "and a patching task", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 305, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 131, + 317 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 305, + 284, + 319 + ], + "score": 1.0, + "content": ", our goal is to produce a new model", + "type": "text" + }, + { + "bbox": [ + 284, + 306, + 306, + 318 + ], + "score": 0.91, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 305, + 445, + 319 + ], + "score": 1.0, + "content": "which achieves high accuracy on", + "type": "text" + }, + { + "bbox": [ + 445, + 306, + 470, + 317 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { { p a t c h } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 305, + 506, + 319 + ], + "score": 1.0, + "content": "without", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 445, + 330 + ], + "score": 1.0, + "content": "decreasing model performance on tasks where accuracy is already acceptable. We let", + "type": "text" + }, + { + "bbox": [ + 446, + 317, + 468, + 329 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 315, + 506, + 330 + ], + "score": 1.0, + "content": "denote a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 327, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 339 + ], + "score": 1.0, + "content": "representative supported task where model performance is adequate, and later show that the method", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 337, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 104, + 337, + 254, + 352 + ], + "score": 1.0, + "content": "is stable under different choices of", + "type": "text" + }, + { + "bbox": [ + 254, + 339, + 277, + 351 + ], + "score": 0.9, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 337, + 506, + 352 + ], + "score": 1.0, + "content": "(Section 4.2). The two-step procedure we explore for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 349, + 234, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 149, + 362 + ], + "score": 1.0, + "content": "producing", + "type": "text" + }, + { + "bbox": [ + 149, + 349, + 171, + 362 + ], + "score": 0.92, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 349, + 234, + 362 + ], + "score": 1.0, + "content": "is given below.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 120, + 374, + 490, + 421 + ], + "lines": [ + { + "bbox": [ + 119, + 374, + 469, + 389 + ], + "spans": [ + { + "bbox": [ + 119, + 374, + 194, + 389 + ], + "score": 1.0, + "content": "Step 1. Fine-tune", + "type": "text" + }, + { + "bbox": [ + 195, + 376, + 207, + 386 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 374, + 295, + 389 + ], + "score": 1.0, + "content": "on training data from", + "type": "text" + }, + { + "bbox": [ + 295, + 376, + 320, + 387 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 374, + 453, + 389 + ], + "score": 1.0, + "content": "to produce a model with weights", + "type": "text" + }, + { + "bbox": [ + 453, + 375, + 464, + 386 + ], + "score": 0.87, + "content": "\\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 374, + 469, + 389 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 119, + 384, + 491, + 399 + ], + "spans": [ + { + "bbox": [ + 119, + 384, + 245, + 399 + ], + "score": 1.0, + "content": "Step 2. For mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 245, + 386, + 285, + 398 + ], + "score": 0.92, + "content": "\\alpha \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 384, + 402, + 399 + ], + "score": 1.0, + "content": ", linearly interpolate between", + "type": "text" + }, + { + "bbox": [ + 402, + 386, + 415, + 397 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 384, + 432, + 399 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 433, + 387, + 444, + 397 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 384, + 491, + 399 + ], + "score": 1.0, + "content": "to produce", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 122, + 396, + 492, + 410 + ], + "spans": [ + { + "bbox": [ + 122, + 397, + 242, + 409 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { p a t c h } } = ( 1 - \\alpha ) \\cdot \\theta _ { \\mathrm { z s } } + \\alpha \\cdot \\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 396, + 492, + 410 + ], + "score": 1.0, + "content": ". The mixing coefficient is determined via held-out validation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 119, + 406, + 387, + 423 + ], + "spans": [ + { + "bbox": [ + 119, + 406, + 154, + 423 + ], + "score": 1.0, + "content": "sets for", + "type": "text" + }, + { + "bbox": [ + 154, + 409, + 176, + 420 + ], + "score": 0.88, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 406, + 194, + 423 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 195, + 409, + 218, + 420 + ], + "score": 0.9, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 406, + 360, + 423 + ], + "score": 1.0, + "content": ". We refer to the resulting model as", + "type": "text" + }, + { + "bbox": [ + 361, + 408, + 382, + 420 + ], + "score": 0.91, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 406, + 387, + 423 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 108, + 434, + 504, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "In our experiments, we do not introduce any additional task-specific parameters when fine-tuning, as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 445, + 300, + 457 + ], + "spans": [ + { + "bbox": [ + 107, + 445, + 289, + 457 + ], + "score": 1.0, + "content": "discussed in Section 3 and Appendices B and", + "type": "text" + }, + { + "bbox": [ + 289, + 446, + 298, + 456 + ], + "score": 0.27, + "content": "\\textrm { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 445, + 300, + 457 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 108, + 461, + 505, + 500 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "Patching on a multiple tasks. In practice, we often want to improve model accuracy on multiple", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 469, + 509, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 191, + 490 + ], + "score": 1.0, + "content": "patching tasks D(1)patch", + "type": "text" + }, + { + "bbox": [ + 167, + 473, + 232, + 489 + ], + "score": 0.92, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } } ^ { ( 1 ) } , . . . , \\mathcal { D } _ { \\mathrm { p a t c h } } ^ { ( k ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 469, + 509, + 493 + ], + "score": 1.0, + "content": "D(k)patch, which can be accomplished with straightforward modifications to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 487, + 507, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 507, + 500 + ], + "score": 1.0, + "content": "the procedure above. We explore three alternatives and examine their relative trade-offs in Section 5:", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 118, + 505, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 115, + 504, + 504, + 521 + ], + "spans": [ + { + "bbox": [ + 115, + 505, + 351, + 521 + ], + "score": 1.0, + "content": "• Joint patching, where we merge all the patching tasks", + "type": "text" + }, + { + "bbox": [ + 351, + 504, + 376, + 521 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathtt { p a t c h } } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 507, + 450, + 520 + ], + "score": 1.0, + "content": "into a single task", + "type": "text" + }, + { + "bbox": [ + 450, + 507, + 475, + 520 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 507, + 504, + 520 + ], + "score": 1.0, + "content": "before", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 124, + 519, + 257, + 532 + ], + "spans": [ + { + "bbox": [ + 124, + 519, + 257, + 532 + ], + "score": 1.0, + "content": "running the patching procedure;", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 117, + 531, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 117, + 531, + 506, + 545 + ], + "score": 1.0, + "content": "• Sequential patching, where we iteratively repeat the patching procedure above on each new task", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 123, + 540, + 357, + 560 + ], + "spans": [ + { + "bbox": [ + 123, + 540, + 150, + 559 + ], + "score": 1.0, + "content": "D(i)", + "type": "text" + }, + { + "bbox": [ + 151, + 543, + 182, + 560 + ], + "score": 1.0, + "content": "and let", + "type": "text" + }, + { + "bbox": [ + 182, + 545, + 230, + 558 + ], + "score": 0.93, + "content": "\\theta _ { \\mathrm { z s } } \\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 543, + 357, + 560 + ], + "score": 1.0, + "content": "after each completed iteration;", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 118, + 559, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 118, + 559, + 505, + 572 + ], + "score": 1.0, + "content": "• Parallel patching, where we apply the first step on each task in parallel to produce fine-tuned", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 217, + 569, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 217, + 570, + 266, + 585 + ], + "score": 0.94, + "content": "\\theta _ { \\mathrm { f t } } ^ { ( 1 ) } , . . . , \\bar { \\theta _ { \\mathrm { f t } } ^ { ( k ) } }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 569, + 444, + 605 + ], + "score": 1.0, + "content": "e search for mixing coefficients .", + "type": "text" + }, + { + "bbox": [ + 445, + 574, + 456, + 584 + ], + "score": 0.83, + "content": "\\alpha _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 569, + 506, + 605 + ], + "score": 1.0, + "content": "to produce", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 585, + 309, + 600 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 309, + 600 + ], + "score": 0.82, + "content": "\\begin{array} { r } { \\theta _ { \\mathrm { p a t c h } } = \\big ( 1 - \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\big ) \\cdot \\theta _ { \\mathrm { z s } } + \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\cdot \\theta _ { \\mathrm { f t } } ^ { ( i ) } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 37 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 108, + 604, + 506, + 648 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 505, + 615 + ], + "score": 1.0, + "content": "For joint and parallel patching we assume access to held-out validation sets for all tasks, while in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 615, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 506, + 626 + ], + "score": 1.0, + "content": "sequential patching we only assume access to held-out validation sets from the tasks seen so far.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 625, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 106, + 625, + 343, + 638 + ], + "score": 1.0, + "content": "Unless mentioned otherwise, we pick the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 343, + 627, + 351, + 636 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 625, + 505, + 638 + ], + "score": 1.0, + "content": "that optimizes average accuracy on the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 636, + 358, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 358, + 649 + ], + "score": 1.0, + "content": "held-out validation sets from the supported and patching tasks.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5 + }, + { + "type": "title", + "bbox": [ + 108, + 658, + 226, + 672 + ], + "lines": [ + { + "bbox": [ + 103, + 655, + 228, + 677 + ], + "spans": [ + { + "bbox": [ + 103, + 655, + 228, + 677 + ], + "score": 1.0, + "content": "3 Experimental setup", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 678, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "Tasks. We consider a diverse set of image classification tasks from Radford et al. [57]. In most", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "experiments, we use ImageNet [14] as a representative supported task, although we explore other", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "supported tasks in Section 4.2. We categorize tasks into patching tasks or supported tasks based on", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "the accuracy difference between the zero-shot model and a model specialized to the task. A large", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 44.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 117 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "Finally, we investigate PAINT on case studies including typographic attacks [23], counting [32], and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "visual question answering [4] (Section 7). For instance, applying PAINT using synthetic typographic", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "attacks leads to a model that is less susceptible to typographic attacks in the real world, improving its", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 244, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 244, + 118 + ], + "score": 1.0, + "content": "accuracy by 41 percentage points.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 72, + 506, + 118 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 122, + 158, + 133 + ], + "lines": [ + { + "bbox": [ + 106, + 121, + 160, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 160, + 136 + ], + "score": 1.0, + "content": "In summary:", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 106, + 121, + 160, + 136 + ] + }, + { + "type": "list", + "bbox": [ + 118, + 138, + 506, + 249 + ], + "lines": [ + { + "bbox": [ + 117, + 139, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 117, + 139, + 505, + 151 + ], + "score": 1.0, + "content": "• Even the best pre-trained models are not perfect. We introduce PAINT, a method designed to", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 151, + 403, + 163 + ], + "spans": [ + { + "bbox": [ + 126, + 151, + 403, + 163 + ], + "score": 1.0, + "content": "improve accuracy on new tasks without harming accuracy elsewhere.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 117, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 117, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "• PAINT incurs no extra computational cost compared to standard fine-tuning, neither during", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 175, + 282, + 186 + ], + "spans": [ + { + "bbox": [ + 126, + 175, + 282, + 186 + ], + "score": 1.0, + "content": "fine-tuning itself nor at inference time.", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 117, + 187, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 117, + 187, + 505, + 200 + ], + "score": 1.0, + "content": "• PAINT can also be applied with multiple tasks, providing a single model that is competitive", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 199, + 251, + 210 + ], + "spans": [ + { + "bbox": [ + 125, + 199, + 251, + 210 + ], + "score": 1.0, + "content": "with many specialized models.", + "type": "text" + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 116, + 211, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 116, + 211, + 506, + 226 + ], + "score": 1.0, + "content": "• Applying PAINT with one task can improve accuracy on a related task, even when they do not", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 222, + 220, + 235 + ], + "spans": [ + { + "bbox": [ + 125, + 222, + 220, + 235 + ], + "score": 1.0, + "content": "share the same classes.", + "type": "text" + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 117, + 236, + 459, + 249 + ], + "spans": [ + { + "bbox": [ + 117, + 236, + 459, + 249 + ], + "score": 1.0, + "content": "• PAINT improves with model scale, indicating a promising trend for future models.", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 9, + "bbox_fs": [ + 116, + 139, + 506, + 249 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 258, + 314, + 272 + ], + "lines": [ + { + "bbox": [ + 104, + 257, + 315, + 275 + ], + "spans": [ + { + "bbox": [ + 104, + 257, + 315, + 275 + ], + "score": 1.0, + "content": "2 Patching with interpolation (PAINT)", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 108, + 277, + 438, + 289 + ], + "lines": [ + { + "bbox": [ + 105, + 276, + 439, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 439, + 291 + ], + "score": 1.0, + "content": "This section details our method for patching models on a single and multiple tasks.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 276, + 439, + 291 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 506, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 294, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 411, + 307 + ], + "score": 1.0, + "content": "Patching on a single task. Given an open-vocabulary model with weights", + "type": "text" + }, + { + "bbox": [ + 411, + 295, + 424, + 306 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 424, + 294, + 506, + 307 + ], + "score": 1.0, + "content": "and a patching task", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 305, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 131, + 317 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 305, + 284, + 319 + ], + "score": 1.0, + "content": ", our goal is to produce a new model", + "type": "text" + }, + { + "bbox": [ + 284, + 306, + 306, + 318 + ], + "score": 0.91, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 305, + 445, + 319 + ], + "score": 1.0, + "content": "which achieves high accuracy on", + "type": "text" + }, + { + "bbox": [ + 445, + 306, + 470, + 317 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { { p a t c h } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 305, + 506, + 319 + ], + "score": 1.0, + "content": "without", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 315, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 445, + 330 + ], + "score": 1.0, + "content": "decreasing model performance on tasks where accuracy is already acceptable. We let", + "type": "text" + }, + { + "bbox": [ + 446, + 317, + 468, + 329 + ], + "score": 0.89, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 315, + 506, + 330 + ], + "score": 1.0, + "content": "denote a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 327, + 506, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 506, + 339 + ], + "score": 1.0, + "content": "representative supported task where model performance is adequate, and later show that the method", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 337, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 104, + 337, + 254, + 352 + ], + "score": 1.0, + "content": "is stable under different choices of", + "type": "text" + }, + { + "bbox": [ + 254, + 339, + 277, + 351 + ], + "score": 0.9, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 337, + 506, + 352 + ], + "score": 1.0, + "content": "(Section 4.2). The two-step procedure we explore for", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 349, + 234, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 149, + 362 + ], + "score": 1.0, + "content": "producing", + "type": "text" + }, + { + "bbox": [ + 149, + 349, + 171, + 362 + ], + "score": 0.92, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 349, + 234, + 362 + ], + "score": 1.0, + "content": "is given below.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 104, + 294, + 506, + 362 + ] + }, + { + "type": "text", + "bbox": [ + 120, + 374, + 490, + 421 + ], + "lines": [ + { + "bbox": [ + 119, + 374, + 469, + 389 + ], + "spans": [ + { + "bbox": [ + 119, + 374, + 194, + 389 + ], + "score": 1.0, + "content": "Step 1. Fine-tune", + "type": "text" + }, + { + "bbox": [ + 195, + 376, + 207, + 386 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 374, + 295, + 389 + ], + "score": 1.0, + "content": "on training data from", + "type": "text" + }, + { + "bbox": [ + 295, + 376, + 320, + 387 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 374, + 453, + 389 + ], + "score": 1.0, + "content": "to produce a model with weights", + "type": "text" + }, + { + "bbox": [ + 453, + 375, + 464, + 386 + ], + "score": 0.87, + "content": "\\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 374, + 469, + 389 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 119, + 384, + 491, + 399 + ], + "spans": [ + { + "bbox": [ + 119, + 384, + 245, + 399 + ], + "score": 1.0, + "content": "Step 2. For mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 245, + 386, + 285, + 398 + ], + "score": 0.92, + "content": "\\alpha \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 384, + 402, + 399 + ], + "score": 1.0, + "content": ", linearly interpolate between", + "type": "text" + }, + { + "bbox": [ + 402, + 386, + 415, + 397 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 384, + 432, + 399 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 433, + 387, + 444, + 397 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 444, + 384, + 491, + 399 + ], + "score": 1.0, + "content": "to produce", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 122, + 396, + 492, + 410 + ], + "spans": [ + { + "bbox": [ + 122, + 397, + 242, + 409 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { p a t c h } } = ( 1 - \\alpha ) \\cdot \\theta _ { \\mathrm { z s } } + \\alpha \\cdot \\theta _ { \\mathrm { f t } }", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 396, + 492, + 410 + ], + "score": 1.0, + "content": ". The mixing coefficient is determined via held-out validation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 119, + 406, + 387, + 423 + ], + "spans": [ + { + "bbox": [ + 119, + 406, + 154, + 423 + ], + "score": 1.0, + "content": "sets for", + "type": "text" + }, + { + "bbox": [ + 154, + 409, + 176, + 420 + ], + "score": 0.88, + "content": "\\mathcal { D } _ { \\mathrm { s u p p } }", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 406, + 194, + 423 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 195, + 409, + 218, + 420 + ], + "score": 0.9, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 406, + 360, + 423 + ], + "score": 1.0, + "content": ". We refer to the resulting model as", + "type": "text" + }, + { + "bbox": [ + 361, + 408, + 382, + 420 + ], + "score": 0.91, + "content": "\\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 406, + 387, + 423 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 119, + 374, + 492, + 423 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 434, + 504, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "score": 1.0, + "content": "In our experiments, we do not introduce any additional task-specific parameters when fine-tuning, as", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 445, + 300, + 457 + ], + "spans": [ + { + "bbox": [ + 107, + 445, + 289, + 457 + ], + "score": 1.0, + "content": "discussed in Section 3 and Appendices B and", + "type": "text" + }, + { + "bbox": [ + 289, + 446, + 298, + 456 + ], + "score": 0.27, + "content": "\\textrm { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 445, + 300, + 457 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 433, + 506, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 461, + 505, + 500 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "Patching on a multiple tasks. In practice, we often want to improve model accuracy on multiple", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 469, + 509, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 191, + 490 + ], + "score": 1.0, + "content": "patching tasks D(1)patch", + "type": "text" + }, + { + "bbox": [ + 167, + 473, + 232, + 489 + ], + "score": 0.92, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } } ^ { ( 1 ) } , . . . , \\mathcal { D } _ { \\mathrm { p a t c h } } ^ { ( k ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 469, + 509, + 493 + ], + "score": 1.0, + "content": "D(k)patch, which can be accomplished with straightforward modifications to", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 487, + 507, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 507, + 500 + ], + "score": 1.0, + "content": "the procedure above. We explore three alternatives and examine their relative trade-offs in Section 5:", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 104, + 461, + 509, + 500 + ] + }, + { + "type": "list", + "bbox": [ + 118, + 505, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 115, + 504, + 504, + 521 + ], + "spans": [ + { + "bbox": [ + 115, + 505, + 351, + 521 + ], + "score": 1.0, + "content": "• Joint patching, where we merge all the patching tasks", + "type": "text" + }, + { + "bbox": [ + 351, + 504, + 376, + 521 + ], + "score": 0.93, + "content": "\\mathcal { D } _ { \\mathtt { p a t c h } } ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 507, + 450, + 520 + ], + "score": 1.0, + "content": "into a single task", + "type": "text" + }, + { + "bbox": [ + 450, + 507, + 475, + 520 + ], + "score": 0.91, + "content": "\\mathcal { D } _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 507, + 504, + 520 + ], + "score": 1.0, + "content": "before", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 124, + 519, + 257, + 532 + ], + "spans": [ + { + "bbox": [ + 124, + 519, + 257, + 532 + ], + "score": 1.0, + "content": "running the patching procedure;", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 117, + 531, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 117, + 531, + 506, + 545 + ], + "score": 1.0, + "content": "• Sequential patching, where we iteratively repeat the patching procedure above on each new task", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 123, + 540, + 357, + 560 + ], + "spans": [ + { + "bbox": [ + 123, + 540, + 150, + 559 + ], + "score": 1.0, + "content": "D(i)", + "type": "text" + }, + { + "bbox": [ + 151, + 543, + 182, + 560 + ], + "score": 1.0, + "content": "and let", + "type": "text" + }, + { + "bbox": [ + 182, + 545, + 230, + 558 + ], + "score": 0.93, + "content": "\\theta _ { \\mathrm { z s } } \\theta _ { \\mathrm { p a t c h } }", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 543, + 357, + 560 + ], + "score": 1.0, + "content": "after each completed iteration;", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 118, + 559, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 118, + 559, + 505, + 572 + ], + "score": 1.0, + "content": "• Parallel patching, where we apply the first step on each task in parallel to produce fine-tuned", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 217, + 569, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 217, + 570, + 266, + 585 + ], + "score": 0.94, + "content": "\\theta _ { \\mathrm { f t } } ^ { ( 1 ) } , . . . , \\bar { \\theta _ { \\mathrm { f t } } ^ { ( k ) } }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 569, + 444, + 605 + ], + "score": 1.0, + "content": "e search for mixing coefficients .", + "type": "text" + }, + { + "bbox": [ + 445, + 574, + 456, + 584 + ], + "score": 0.83, + "content": "\\alpha _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 569, + 506, + 605 + ], + "score": 1.0, + "content": "to produce", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 585, + 309, + 600 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 309, + 600 + ], + "score": 0.82, + "content": "\\begin{array} { r } { \\theta _ { \\mathrm { p a t c h } } = \\big ( 1 - \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\big ) \\cdot \\theta _ { \\mathrm { z s } } + \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\cdot \\theta _ { \\mathrm { f t } } ^ { ( i ) } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 37, + "is_list_end_line": true + } + ], + "index": 34, + "bbox_fs": [ + 115, + 504, + 506, + 605 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 604, + 506, + 648 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 505, + 615 + ], + "score": 1.0, + "content": "For joint and parallel patching we assume access to held-out validation sets for all tasks, while in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 615, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 615, + 506, + 626 + ], + "score": 1.0, + "content": "sequential patching we only assume access to held-out validation sets from the tasks seen so far.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 625, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 106, + 625, + 343, + 638 + ], + "score": 1.0, + "content": "Unless mentioned otherwise, we pick the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 343, + 627, + 351, + 636 + ], + "score": 0.78, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 625, + 505, + 638 + ], + "score": 1.0, + "content": "that optimizes average accuracy on the", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 636, + 358, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 358, + 649 + ], + "score": 1.0, + "content": "held-out validation sets from the supported and patching tasks.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 604, + 506, + 649 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 658, + 226, + 672 + ], + "lines": [ + { + "bbox": [ + 103, + 655, + 228, + 677 + ], + "spans": [ + { + "bbox": [ + 103, + 655, + 228, + 677 + ], + "score": 1.0, + "content": "3 Experimental setup", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 678, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "Tasks. We consider a diverse set of image classification tasks from Radford et al. [57]. In most", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "experiments, we use ImageNet [14] as a representative supported task, although we explore other", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "supported tasks in Section 4.2. We categorize tasks into patching tasks or supported tasks based on", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "the accuracy difference between the zero-shot model and a model specialized to the task. A large", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "accuracy difference indicates that the task is a relevant target for patching because the zero-shot", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "score": 1.0, + "content": "model is still far from optimal. Specifically, we consider a subset tasks from Radford et al. [57],", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "categorizing tasks where the linear probes outperform the zero-shot model by over 10 percentage", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "points as patching tasks: Cars [35], DTD [11], EuroSAT [25], GTSRB [71], KITTI [22], MNIST", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "[39], RESISC45 [7], SUN397 [84], and SVHN [53]. We use the remaining tasks as supported tasks:", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "CIFAR10 [36], CIFAR100 [36], Food101 [5], ImageNet [14], and STL10 [12]. We investigate", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 138, + 490, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 490, + 150 + ], + "score": 1.0, + "content": "additional patching tasks as case studies in Section 7 and provide further details in Appendix A.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 677, + 506, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 150 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "accuracy difference indicates that the task is a relevant target for patching because the zero-shot", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "score": 1.0, + "content": "model is still far from optimal. Specifically, we consider a subset tasks from Radford et al. [57],", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "categorizing tasks where the linear probes outperform the zero-shot model by over 10 percentage", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "points as patching tasks: Cars [35], DTD [11], EuroSAT [25], GTSRB [71], KITTI [22], MNIST", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 506, + 129 + ], + "score": 1.0, + "content": "[39], RESISC45 [7], SUN397 [84], and SVHN [53]. We use the remaining tasks as supported tasks:", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "CIFAR10 [36], CIFAR100 [36], Food101 [5], ImageNet [14], and STL10 [12]. We investigate", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 138, + 490, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 138, + 490, + 150 + ], + "score": 1.0, + "content": "additional patching tasks as case studies in Section 7 and provide further details in Appendix A.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "score": 1.0, + "content": "Models. We primarily use CLIP [57] pre-trained vision transformer (ViT) models [15]. Unless other-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 169, + 506, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 506, + 182 + ], + "score": 1.0, + "content": "wise mentioned our experiments are with the ViT-L/14 model, while Section 4.2 studies ResNets [24].", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 189, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 189, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 505, + 200 + ], + "score": 1.0, + "content": "Fine-tuning on patching tasks. Unless otherwise mentioned, we fine-tune with a batch size of 128", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 199, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 214 + ], + "score": 1.0, + "content": "for 2000 iterations using learning rate 1e-5 with 200 warm-up steps with a cosine annealing learning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 211, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 223 + ], + "score": 1.0, + "content": "rate schedule and the AdamW optimizer [43, 55] (weight decay 0.1). When fine-tuning, we use the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "frozen final classification layer output by CLIP’s text tower so that we do not introduce additional", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "score": 1.0, + "content": "learnable parameters. This design decision keeps the model open-vocabulary and does not harm", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 244, + 305, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 305, + 256 + ], + "score": 1.0, + "content": "accuracy, as discussed in in Appendices B and C.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "Evaluation. We use accuracy as the evaluation metric unless otherwise stated. We refer to the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "average of the mean accuracy on the patching tasks and the mean accuracy on the supported tasks as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 285, + 192, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 192, + 298 + ], + "score": 1.0, + "content": "combined accuracy.2", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 107, + 310, + 315, + 323 + ], + "lines": [ + { + "bbox": [ + 104, + 308, + 316, + 326 + ], + "spans": [ + { + "bbox": [ + 104, + 308, + 316, + 326 + ], + "score": 1.0, + "content": "4 Patching models on a single new task", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 330, + 505, + 397 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "As shown in Figure 1, when patching a model on a single task, we interpolate the weights of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 340, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 355 + ], + "score": 1.0, + "content": "zero-shot and fine-tuned model, producing a model that achieves high accuracy on both the patching", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "score": 1.0, + "content": "task and the supported task. On the nine tasks, PAINT improves the accuracy of ViT-L/14 by 15 to 60", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "score": 1.0, + "content": "percentage points, while accuracy on ImageNet decreases by less than one percentage point. PAINT", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 375, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 386 + ], + "score": 1.0, + "content": "also allows practitioners to control the accuracy trade-off on the patching and supported tasks without", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 385, + 353, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 342, + 398 + ], + "score": 1.0, + "content": "re-training a new model, by varying the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 342, + 387, + 349, + 395 + ], + "score": 0.73, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 385, + 353, + 398 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 107, + 406, + 207, + 418 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 207, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 207, + 419 + ], + "score": 1.0, + "content": "4.1 The effect of scale", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 422, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "score": 1.0, + "content": "We consistently observe that PAINT is more effective for larger models. Our findings are aligned with", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "those of Ramasesh et al. [59], who observed that larger models are less susceptible to catastrophic", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 444, + 426, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 426, + 457 + ], + "score": 1.0, + "content": "forgetting. This section formalizes and provides insights for these observations.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 464, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "score": 1.0, + "content": "Measuring the effectiveness of patching. We measure the effectiveness of patching via the accuracy", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "difference between the single patched model and two specialized models with the same architecture", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "score": 1.0, + "content": "and initialization. For both the supported task and patching task, we take specialized models that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 497, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 509 + ], + "score": 1.0, + "content": "maximize performance on the task, considering the set of all interpolations between the zero-shot", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 507, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 522 + ], + "score": 1.0, + "content": "and fine-tuned models. We refer to this measure as accuracy distance to optimal. Formally, accuracy", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 519, + 230, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 230, + 531 + ], + "score": 1.0, + "content": "distance to optimal is given by", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + }, + { + "type": "interline_equation", + "bbox": [ + 110, + 537, + 488, + 561 + ], + "lines": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "spans": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "score": 0.9, + "content": "\\frac { 1 } { 2 } \\left[ \\operatorname* { m a x } _ { \\alpha } \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { s u p p } } ) + \\operatorname* { m a x } _ { \\alpha } \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { p a t c h } } ) \\right] - \\frac { 1 } { 2 } \\operatorname* { m a x } _ { \\alpha } \\left[ \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { s u p p } } ) + \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { p a t c h } } ) \\right] ,", + "type": "interline_equation", + "image_path": "8b7c17fc63adfde3b41dd8fdcc1945f8f446229365359c91fe06bd64742dcd34.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 569, + 505, + 603 + ], + "lines": [ + { + "bbox": [ + 106, + 569, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 134, + 581 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 569, + 176, + 581 + ], + "score": 0.92, + "content": "\\operatorname { A c c } ( \\theta , { \\mathcal { D } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 569, + 316, + 581 + ], + "score": 1.0, + "content": "represents the accuracy of model", + "type": "text" + }, + { + "bbox": [ + 317, + 570, + 324, + 579 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 569, + 357, + 581 + ], + "score": 1.0, + "content": "on task", + "type": "text" + }, + { + "bbox": [ + 358, + 570, + 367, + 579 + ], + "score": 0.79, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 569, + 506, + 581 + ], + "score": 1.0, + "content": ". In Figure 2 (left), we show that", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 579, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 592 + ], + "score": 1.0, + "content": "accuracy distance to optimal decreases with scale, indicating that patching becomes more effective", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 591, + 180, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 180, + 603 + ], + "score": 1.0, + "content": "for larger models.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 106, + 610, + 505, + 689 + ], + "lines": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Model similarity. Fine-tuning modifies overparameterized models less [9], which provides insights", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 622, + 506, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 634 + ], + "score": 1.0, + "content": "on why larger models are easier to patch: less movement is required to fit new data. We demonstrate", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 632, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 646 + ], + "score": 1.0, + "content": "this by evaluating representational similarity using Centered Kernel Alignment (CKA) [34] (see", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 148, + 657 + ], + "score": 1.0, + "content": "Appendix", + "type": "text" + }, + { + "bbox": [ + 148, + 644, + 158, + 654 + ], + "score": 0.43, + "content": "\\mathrm { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "for details). As shown in Figure 2 (center), the representations of the unpatched and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 653, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 506, + 668 + ], + "score": 1.0, + "content": "fine-tuned models become more similar as models grow larger, indicated by larger CKA values.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "Moreover, Figure 2 (right) shows that the cosine similarity between the weights of the unpatched and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 676, + 421, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 183, + 690 + ], + "score": 1.0, + "content": "fine-tuned models,", + "type": "text" + }, + { + "bbox": [ + 183, + 676, + 333, + 689 + ], + "score": 0.91, + "content": "\\mathrm { c o s } \\bar { ( \\theta _ { \\mathrm { z s } } , \\theta _ { \\mathrm { f t } } ) } = { \\langle \\theta _ { \\mathrm { z s } } , \\theta _ { \\mathrm { f t } } \\rangle } / ( { | | \\theta _ { \\mathrm { z s } } | } { | | \\theta _ { \\mathrm { f t } } | } { | | } )", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 676, + 421, + 690 + ], + "score": 1.0, + "content": ", increases with scale.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 700, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 504, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 178, + 714 + ], + "score": 1.0, + "content": "2In other words,", + "type": "text" + }, + { + "bbox": [ + 178, + 701, + 360, + 713 + ], + "score": 0.89, + "content": "( \\mathbb { E } _ { \\mathcal { D } _ { \\mathrm { s u p p } } } [ \\mathsf { A c c } ( \\theta , \\mathcal { D } _ { \\mathrm { s u p p } } ) ] + \\mathbb { E } _ { \\mathcal { D } _ { \\mathrm { p a t c h } } } [ \\mathsf { A c c } ( \\theta , \\mathcal { D } _ { \\mathrm { p a t c h } } ) ] ) / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 699, + 387, + 714 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 387, + 701, + 437, + 713 + ], + "score": 0.9, + "content": "\\mathsf { A c c } ( \\theta , \\mathcal { D } _ { \\mathrm { s u p p } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 699, + 453, + 714 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 453, + 701, + 504, + 713 + ], + "score": 0.9, + "content": "{ \\sf A c c } ( \\theta , { \\mathcal { D } } _ { \\mathrm { p a t c h } } )", + "type": "inline_equation" + } + ] + }, + { + "bbox": [ + 106, + 711, + 346, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 346, + 723 + ], + "score": 1.0, + "content": "are accuracies on supported tasks and patching tasks, respectively.", + "type": "text" + } + ] + } + ] + }, + { + "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": [ + 107, + 72, + 505, + 150 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 105, + 72, + 506, + 150 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 504, + 181 + ], + "lines": [ + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 171 + ], + "score": 1.0, + "content": "Models. We primarily use CLIP [57] pre-trained vision transformer (ViT) models [15]. Unless other-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 169, + 506, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 506, + 182 + ], + "score": 1.0, + "content": "wise mentioned our experiments are with the ViT-L/14 model, while Section 4.2 studies ResNets [24].", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 158, + 506, + 182 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 189, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 189, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 505, + 200 + ], + "score": 1.0, + "content": "Fine-tuning on patching tasks. Unless otherwise mentioned, we fine-tune with a batch size of 128", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 199, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 214 + ], + "score": 1.0, + "content": "for 2000 iterations using learning rate 1e-5 with 200 warm-up steps with a cosine annealing learning", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 211, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 505, + 223 + ], + "score": 1.0, + "content": "rate schedule and the AdamW optimizer [43, 55] (weight decay 0.1). When fine-tuning, we use the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 222, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 505, + 234 + ], + "score": 1.0, + "content": "frozen final classification layer output by CLIP’s text tower so that we do not introduce additional", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 505, + 246 + ], + "score": 1.0, + "content": "learnable parameters. This design decision keeps the model open-vocabulary and does not harm", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 244, + 305, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 305, + 256 + ], + "score": 1.0, + "content": "accuracy, as discussed in in Appendices B and C.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 189, + 505, + 256 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 276 + ], + "score": 1.0, + "content": "Evaluation. We use accuracy as the evaluation metric unless otherwise stated. We refer to the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 287 + ], + "score": 1.0, + "content": "average of the mean accuracy on the patching tasks and the mean accuracy on the supported tasks as", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 285, + 192, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 192, + 298 + ], + "score": 1.0, + "content": "combined accuracy.2", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 263, + 505, + 298 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 310, + 315, + 323 + ], + "lines": [ + { + "bbox": [ + 104, + 308, + 316, + 326 + ], + "spans": [ + { + "bbox": [ + 104, + 308, + 316, + 326 + ], + "score": 1.0, + "content": "4 Patching models on a single new task", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 330, + 505, + 397 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "As shown in Figure 1, when patching a model on a single task, we interpolate the weights of the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 340, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 505, + 355 + ], + "score": 1.0, + "content": "zero-shot and fine-tuned model, producing a model that achieves high accuracy on both the patching", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "score": 1.0, + "content": "task and the supported task. On the nine tasks, PAINT improves the accuracy of ViT-L/14 by 15 to 60", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 506, + 376 + ], + "score": 1.0, + "content": "percentage points, while accuracy on ImageNet decreases by less than one percentage point. PAINT", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 375, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 386 + ], + "score": 1.0, + "content": "also allows practitioners to control the accuracy trade-off on the patching and supported tasks without", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 385, + 353, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 342, + 398 + ], + "score": 1.0, + "content": "re-training a new model, by varying the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 342, + 387, + 349, + 395 + ], + "score": 0.73, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 385, + 353, + 398 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 330, + 506, + 398 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 406, + 207, + 418 + ], + "lines": [ + { + "bbox": [ + 106, + 406, + 207, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 207, + 419 + ], + "score": 1.0, + "content": "4.1 The effect of scale", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 422, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "score": 1.0, + "content": "We consistently observe that PAINT is more effective for larger models. Our findings are aligned with", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "those of Ramasesh et al. [59], who observed that larger models are less susceptible to catastrophic", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 444, + 426, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 426, + 457 + ], + "score": 1.0, + "content": "forgetting. This section formalizes and provides insights for these observations.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 422, + 505, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 464, + 505, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 477 + ], + "score": 1.0, + "content": "Measuring the effectiveness of patching. We measure the effectiveness of patching via the accuracy", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "difference between the single patched model and two specialized models with the same architecture", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 505, + 498 + ], + "score": 1.0, + "content": "and initialization. For both the supported task and patching task, we take specialized models that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 497, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 509 + ], + "score": 1.0, + "content": "maximize performance on the task, considering the set of all interpolations between the zero-shot", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 507, + 505, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 522 + ], + "score": 1.0, + "content": "and fine-tuned models. We refer to this measure as accuracy distance to optimal. Formally, accuracy", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 519, + 230, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 230, + 531 + ], + "score": 1.0, + "content": "distance to optimal is given by", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 462, + 506, + 531 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 110, + 537, + 488, + 561 + ], + "lines": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "spans": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "score": 0.9, + "content": "\\frac { 1 } { 2 } \\left[ \\operatorname* { m a x } _ { \\alpha } \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { s u p p } } ) + \\operatorname* { m a x } _ { \\alpha } \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { p a t c h } } ) \\right] - \\frac { 1 } { 2 } \\operatorname* { m a x } _ { \\alpha } \\left[ \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { s u p p } } ) + \\mathsf { A c c } ( \\theta _ { \\alpha } , { \\mathcal D } _ { \\mathrm { p a t c h } } ) \\right] ,", + "type": "interline_equation", + "image_path": "8b7c17fc63adfde3b41dd8fdcc1945f8f446229365359c91fe06bd64742dcd34.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 110, + 537, + 488, + 561 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 569, + 505, + 603 + ], + "lines": [ + { + "bbox": [ + 106, + 569, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 134, + 581 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 569, + 176, + 581 + ], + "score": 0.92, + "content": "\\operatorname { A c c } ( \\theta , { \\mathcal { D } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 569, + 316, + 581 + ], + "score": 1.0, + "content": "represents the accuracy of model", + "type": "text" + }, + { + "bbox": [ + 317, + 570, + 324, + 579 + ], + "score": 0.76, + "content": "\\theta", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 569, + 357, + 581 + ], + "score": 1.0, + "content": "on task", + "type": "text" + }, + { + "bbox": [ + 358, + 570, + 367, + 579 + ], + "score": 0.79, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 569, + 506, + 581 + ], + "score": 1.0, + "content": ". In Figure 2 (left), we show that", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 579, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 505, + 592 + ], + "score": 1.0, + "content": "accuracy distance to optimal decreases with scale, indicating that patching becomes more effective", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 591, + 180, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 180, + 603 + ], + "score": 1.0, + "content": "for larger models.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 569, + 506, + 603 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 610, + 505, + 689 + ], + "lines": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Model similarity. Fine-tuning modifies overparameterized models less [9], which provides insights", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 622, + 506, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 634 + ], + "score": 1.0, + "content": "on why larger models are easier to patch: less movement is required to fit new data. We demonstrate", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 632, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 646 + ], + "score": 1.0, + "content": "this by evaluating representational similarity using Centered Kernel Alignment (CKA) [34] (see", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 148, + 657 + ], + "score": 1.0, + "content": "Appendix", + "type": "text" + }, + { + "bbox": [ + 148, + 644, + 158, + 654 + ], + "score": 0.43, + "content": "\\mathrm { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "for details). As shown in Figure 2 (center), the representations of the unpatched and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 653, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 506, + 668 + ], + "score": 1.0, + "content": "fine-tuned models become more similar as models grow larger, indicated by larger CKA values.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "Moreover, Figure 2 (right) shows that the cosine similarity between the weights of the unpatched and", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 676, + 421, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 183, + 690 + ], + "score": 1.0, + "content": "fine-tuned models,", + "type": "text" + }, + { + "bbox": [ + 183, + 676, + 333, + 689 + ], + "score": 0.91, + "content": "\\mathrm { c o s } \\bar { ( \\theta _ { \\mathrm { z s } } , \\theta _ { \\mathrm { f t } } ) } = { \\langle \\theta _ { \\mathrm { z s } } , \\theta _ { \\mathrm { f t } } \\rangle } / ( { | | \\theta _ { \\mathrm { z s } } | } { | | \\theta _ { \\mathrm { f t } } | } { | | } )", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 676, + 421, + 690 + ], + "score": 1.0, + "content": ", increases with scale.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 611, + 506, + 690 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 74, + 503, + 199 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 74, + 503, + 199 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 74, + 503, + 199 + ], + "spans": [ + { + "bbox": [ + 109, + 74, + 503, + 199 + ], + "score": 0.967, + "type": "image", + "image_path": "b72c4fb36424a430ec0f1a0abae638b6b4155247529a5a5b91ced0b946da30bc.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 74, + 503, + 115.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 115.66666666666666, + 503, + 157.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 157.33333333333331, + 503, + 198.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 206, + 505, + 241 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "Figure 2: Larger models are easier to patch (left). For larger models, the unpatched and fine-tuned", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "model are more similar with respect to their representations (center) and weights (right). Model scale", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 229, + 366, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 366, + 241 + ], + "score": 1.0, + "content": "is measured in Giga Multiply-Accumulate operations (GMACs).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 109, + 255, + 502, + 388 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 255, + 502, + 388 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 255, + 502, + 388 + ], + "spans": [ + { + "bbox": [ + 109, + 255, + 502, + 388 + ], + "score": 0.968, + "type": "image", + "image_path": "2443ac9955361eaece32bc9fb65f1d64c8d05723641e59f827424243e6ead873.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 109, + 255, + 502, + 299.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 299.3333333333333, + 502, + 343.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 109, + 343.66666666666663, + 502, + 387.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 399, + 506, + 443 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 399, + 507, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 507, + 412 + ], + "score": 1.0, + "content": "Figure 3: The frontier of accuracy trade-offs can be recovered by linearly interpolating weights.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 410, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 424 + ], + "score": 1.0, + "content": "Interpolating the unpatched and fine-tuned models recovers the accuracy trade-off of early stopping,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "score": 1.0, + "content": "regularization towards the initialization, and changes in hyperparameters. Additional details and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 433, + 276, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 276, + 444 + ], + "score": 1.0, + "content": "comparisons can be found in Appendix E.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + } + ], + "index": 8.75 + }, + { + "type": "title", + "bbox": [ + 107, + 459, + 230, + 470 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 231, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 231, + 472 + ], + "score": 1.0, + "content": "4.2 Baselines and ablations", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 505, + 574 + ], + "lines": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Baselines. There are many alternatives which enable a trade-off between accuracy on the supported", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 484, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 499 + ], + "score": 1.0, + "content": "and patching tasks. These methods include early stopping during fine-tuning, applying a regularization", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "term which penalizes movement from initialization, or training with different hyperparameters", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 507, + 504, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 504, + 520 + ], + "score": 1.0, + "content": "including a smaller learning rate. Unlike interpolation, these methods do not enable navigating the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 518, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 531 + ], + "score": 1.0, + "content": "accuracy trade-off without fine-tuning the model again many times. Moreover, Figure 3 demonstrates", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "that the accuracy trade-off frontier for early stopping, regularization, or varying hyperparameters", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 540, + 459, + 553 + ], + "score": 1.0, + "content": "can be recovered by interpolating weights with different mixing coefficients. Appendix", + "type": "text" + }, + { + "bbox": [ + 459, + 541, + 467, + 550 + ], + "score": 0.43, + "content": "\\mathrm { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "provides", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 550, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 564 + ], + "score": 1.0, + "content": "additional baselines and discussion, including EMA [74], EWC [33], LwF [41], re-training a model", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 562, + 460, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 460, + 575 + ], + "score": 1.0, + "content": "with data from the patching task, and mixing the pre-training and fine-tuning objectives.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "Additional supported tasks. In Figure 1, we use ImageNet as a representative supported task. This", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "section demonstrates that PAINT is stable under different choices of the supported task. Instead", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "of ImageNet, we use CIFAR10, CIFAR100, Food101 and STL10. Figure 4 displays representative", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 615, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 439, + 627 + ], + "score": 1.0, + "content": "results, where performance is averaged over the nine patching tasks (see Appendix", + "type": "text" + }, + { + "bbox": [ + 440, + 616, + 448, + 625 + ], + "score": 0.3, + "content": "\\mathrm { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 615, + 505, + 627 + ], + "score": 1.0, + "content": "for additional", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "score": 1.0, + "content": "results). We observe consistent results across supported tasks, and that the optimal mixing coefficients", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 636, + 387, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 387, + 649 + ], + "score": 1.0, + "content": "are stable across different choices of supported tasks (Figure 4, right).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "Additional models. In addition to the CLIP ViTs used in the majority of our experiments, we study", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "four ResNet models [24] from Radford et al. [57] in Appendix G. We find that patching is less", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "effective for ResNets compared to ViTs of similar size, which corroborates the findings of Ramasesh", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "et al. [59] that ResNets are generally more susceptible to catastrophic forgetting. However, similarly", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "to ViTs, we still observe improvements with scale. Finally, we show that patching is also effective for", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 711, + 277, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 277, + 722 + ], + "score": 1.0, + "content": "closed-vocabulary models in Appendix H.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 740, + 309, + 753 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 74, + 503, + 199 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 74, + 503, + 199 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 74, + 503, + 199 + ], + "spans": [ + { + "bbox": [ + 109, + 74, + 503, + 199 + ], + "score": 0.967, + "type": "image", + "image_path": "b72c4fb36424a430ec0f1a0abae638b6b4155247529a5a5b91ced0b946da30bc.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 74, + 503, + 115.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 115.66666666666666, + 503, + 157.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 157.33333333333331, + 503, + 198.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 206, + 505, + 241 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 505, + 219 + ], + "score": 1.0, + "content": "Figure 2: Larger models are easier to patch (left). For larger models, the unpatched and fine-tuned", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 106, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "model are more similar with respect to their representations (center) and weights (right). Model scale", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 229, + 366, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 366, + 241 + ], + "score": 1.0, + "content": "is measured in Giga Multiply-Accumulate operations (GMACs).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 109, + 255, + 502, + 388 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 255, + 502, + 388 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 109, + 255, + 502, + 388 + ], + "spans": [ + { + "bbox": [ + 109, + 255, + 502, + 388 + ], + "score": 0.968, + "type": "image", + "image_path": "2443ac9955361eaece32bc9fb65f1d64c8d05723641e59f827424243e6ead873.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 109, + 255, + 502, + 299.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 299.3333333333333, + 502, + 343.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 109, + 343.66666666666663, + 502, + 387.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 399, + 506, + 443 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 399, + 507, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 507, + 412 + ], + "score": 1.0, + "content": "Figure 3: The frontier of accuracy trade-offs can be recovered by linearly interpolating weights.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 410, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 424 + ], + "score": 1.0, + "content": "Interpolating the unpatched and fine-tuned models recovers the accuracy trade-off of early stopping,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 506, + 433 + ], + "score": 1.0, + "content": "regularization towards the initialization, and changes in hyperparameters. Additional details and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 433, + 276, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 276, + 444 + ], + "score": 1.0, + "content": "comparisons can be found in Appendix E.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + } + ], + "index": 8.75 + }, + { + "type": "title", + "bbox": [ + 107, + 459, + 230, + 470 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 231, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 231, + 472 + ], + "score": 1.0, + "content": "4.2 Baselines and ablations", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 505, + 574 + ], + "lines": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Baselines. There are many alternatives which enable a trade-off between accuracy on the supported", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 484, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 499 + ], + "score": 1.0, + "content": "and patching tasks. These methods include early stopping during fine-tuning, applying a regularization", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "term which penalizes movement from initialization, or training with different hyperparameters", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 507, + 504, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 504, + 520 + ], + "score": 1.0, + "content": "including a smaller learning rate. Unlike interpolation, these methods do not enable navigating the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 518, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 531 + ], + "score": 1.0, + "content": "accuracy trade-off without fine-tuning the model again many times. Moreover, Figure 3 demonstrates", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "that the accuracy trade-off frontier for early stopping, regularization, or varying hyperparameters", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 540, + 505, + 553 + ], + "spans": [ + { + "bbox": [ + 106, + 540, + 459, + 553 + ], + "score": 1.0, + "content": "can be recovered by interpolating weights with different mixing coefficients. Appendix", + "type": "text" + }, + { + "bbox": [ + 459, + 541, + 467, + 550 + ], + "score": 0.43, + "content": "\\mathrm { E }", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 540, + 505, + 553 + ], + "score": 1.0, + "content": "provides", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 550, + 505, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 564 + ], + "score": 1.0, + "content": "additional baselines and discussion, including EMA [74], EWC [33], LwF [41], re-training a model", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 562, + 460, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 460, + 575 + ], + "score": 1.0, + "content": "with data from the patching task, and mixing the pre-training and fine-tuning objectives.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 474, + 506, + 575 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 648 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "Additional supported tasks. In Figure 1, we use ImageNet as a representative supported task. This", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "section demonstrates that PAINT is stable under different choices of the supported task. Instead", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "of ImageNet, we use CIFAR10, CIFAR100, Food101 and STL10. Figure 4 displays representative", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 615, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 439, + 627 + ], + "score": 1.0, + "content": "results, where performance is averaged over the nine patching tasks (see Appendix", + "type": "text" + }, + { + "bbox": [ + 440, + 616, + 448, + 625 + ], + "score": 0.3, + "content": "\\mathrm { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 615, + 505, + 627 + ], + "score": 1.0, + "content": "for additional", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 638 + ], + "score": 1.0, + "content": "results). We observe consistent results across supported tasks, and that the optimal mixing coefficients", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 636, + 387, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 387, + 649 + ], + "score": 1.0, + "content": "are stable across different choices of supported tasks (Figure 4, right).", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 581, + 505, + 649 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 656, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "Additional models. In addition to the CLIP ViTs used in the majority of our experiments, we study", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "four ResNet models [24] from Radford et al. [57] in Appendix G. We find that patching is less", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "effective for ResNets compared to ViTs of similar size, which corroborates the findings of Ramasesh", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "et al. [59] that ResNets are generally more susceptible to catastrophic forgetting. However, similarly", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 712 + ], + "score": 1.0, + "content": "to ViTs, we still observe improvements with scale. Finally, we show that patching is also effective for", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 711, + 277, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 277, + 722 + ], + "score": 1.0, + "content": "closed-vocabulary models in Appendix H.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 654, + 506, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 74, + 501, + 184 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 74, + 501, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 74, + 501, + 184 + ], + "spans": [ + { + "bbox": [ + 109, + 74, + 501, + 184 + ], + "score": 0.961, + "type": "image", + "image_path": "4fadd75b187a9012519acf4b3f049b196caf35139ece0e9667ceb2b469c2d014.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 74, + 501, + 110.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 110.66666666666666, + 501, + 147.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 147.33333333333331, + 501, + 183.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 192, + 505, + 247 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 506, + 206 + ], + "score": 1.0, + "content": "Figure 4: Results are consistent across supported tasks. For multiple supported tasks, we observe", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "score": 1.0, + "content": "similar accuracy improvements on patching tasks, without substantially decreasing supported task", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "accuracy. Additional results for the supported tasks Food101, STL10 and ImageNet are in Appendix", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 223, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 104, + 223, + 506, + 239 + ], + "score": 1.0, + "content": "F. Moreover, choosing the mixing coefficients using a different supported task does not substantially", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 235, + 383, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 383, + 249 + ], + "score": 1.0, + "content": "decrease combined accuracy on patching and supported tasks (right).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "title", + "bbox": [ + 107, + 259, + 300, + 273 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 301, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 301, + 276 + ], + "score": 1.0, + "content": "5 Patching models on multiple tasks", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 279, + 506, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "score": 1.0, + "content": "This section details experimental results for patching on multiple datasets. Recall from Section 2", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 290, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 506, + 303 + ], + "score": 1.0, + "content": "that there are various strategies for extending PAINT to multiple datasets, which we briefly revisit.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 300, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 505, + 315 + ], + "score": 1.0, + "content": "For joint patching we merge all the datasets into a single fine-tuning task and apply our patching", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "procedure as before. For sequential patching we iteratively perform our procedure once per task,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 322, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 335 + ], + "score": 1.0, + "content": "using the patched model at each step as the initialization for the next step.3 We also explore parallel", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 300, + 347 + ], + "score": 1.0, + "content": "patching, for which we have an unpatched model", + "type": "text" + }, + { + "bbox": [ + 300, + 334, + 313, + 345 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 334, + 506, + 347 + ], + "score": 1.0, + "content": "and independently fine-tune on each of the tasks", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 474, + 358 + ], + "score": 1.0, + "content": "in parallel. We then search for mixing coefficients to combine the resulting models. For tasks", + "type": "text" + }, + { + "bbox": [ + 474, + 345, + 502, + 357 + ], + "score": 0.91, + "content": "1 , . . . , k", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 345, + 506, + 358 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 101, + 353, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 101, + 353, + 143, + 376 + ], + "score": 1.0, + "content": "let θ(1)ft , .", + "type": "text" + }, + { + "bbox": [ + 120, + 356, + 169, + 371 + ], + "score": 0.93, + "content": "\\theta _ { \\mathrm { f t } } ^ { ( 1 ) } , . . . , \\theta _ { \\mathrm { f t } } ^ { ( k ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 354, + 505, + 375 + ], + "score": 1.0, + "content": "denote the fine-tuned models for each task. Since it is impractical to exhaustively", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 175, + 382 + ], + "score": 1.0, + "content": "search over each", + "type": "text" + }, + { + "bbox": [ + 176, + 371, + 186, + 380 + ], + "score": 0.84, + "content": "\\alpha _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 369, + 385, + 382 + ], + "score": 1.0, + "content": ", we instead search over a one-dimensional scalar", + "type": "text" + }, + { + "bbox": [ + 385, + 370, + 425, + 381 + ], + "score": 0.92, + "content": "\\alpha \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 369, + 505, + 382 + ], + "score": 1.0, + "content": ", which interpolates", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 380, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 142, + 397 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 143, + 383, + 155, + 394 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 380, + 330, + 397 + ], + "score": 1.0, + "content": "and the average of all fine-tuned solutions", + "type": "text" + }, + { + "bbox": [ + 331, + 380, + 379, + 396 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\frac { 1 } { k } \\sum _ { i = 1 } ^ { k } \\theta _ { \\mathrm { f t } } ^ { ( i ) } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 380, + 505, + 397 + ], + "score": 1.0, + "content": ".4 Appendix J provides further", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 395, + 191, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 191, + 406 + ], + "score": 1.0, + "content": "experimental details.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 455 + ], + "lines": [ + { + "bbox": [ + 105, + 410, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 505, + 424 + ], + "score": 1.0, + "content": "These methods have various trade-offs and may be applicable for different scenarios. Joint patching", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "is only possible when data from all tasks you wish to patch is available. On the other hand, sequential", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 433, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 446 + ], + "score": 1.0, + "content": "patching is appropriate when the tasks are observed one after another. Finally, parallel patching can", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 444, + 229, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 229, + 456 + ], + "score": 1.0, + "content": "leverage distributed hardware.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "Figure 5 displays experimental results when patching on all nine tasks from Section 4. We observe", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "score": 1.0, + "content": "that joint patching is the best-performing method on average. This is perhaps unsurprising since", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "joint patching has simultaneous access to all patching datasets, unlike other patching strategies.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "Nevertheless, it is still interesting that for ViT-L/14, joint patching yields a single model with only 0.5", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "percentage points worse combined accuracy than using multiple specialized models.5 Joint patching", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "also achieves a 15.8 percentage points improvement over the unpatched model. Moreover, patching a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "ViT-B/32 model with the joint strategy achieves a combined accuracy 6.1 percentage points higher", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 537, + 386, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 307, + 549 + ], + "score": 1.0, + "content": "than a ViT-L/14 unpatched model, which requires", + "type": "text" + }, + { + "bbox": [ + 307, + 538, + 324, + 548 + ], + "score": 0.28, + "content": "1 2 \\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 537, + 386, + 549 + ], + "score": 1.0, + "content": "more GMACs.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 554, + 505, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "The accuracy of sequential patching approaches that of joint patching, especially for larger models.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "Note that, unlike in joint patching, forgetting can compound since the patching procedure is applied", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "multiple times in sequence. In sequential patching, weight interpolations do not completely eradicate", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 586, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 601 + ], + "score": 1.0, + "content": "forgetting, but greatly mitigate it. This is most noticeable for smaller models: sequentially fine-tuning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "score": 1.0, + "content": "a ViT-B/32 without interpolation reduces the combined accuracy by 4.6 percentage points compared", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "to the unpatched model, as shown in Appendix J. This is compared to a combined accuracy increase", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "of 11 percentage points when using sequential patching. Additional results, including experiments on", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 631, + 293, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 293, + 643 + ], + "score": 1.0, + "content": "SplitCIFAR [61], can be found in Appendix J.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 661 + ], + "score": 1.0, + "content": "Finally, parallel patching underperforms other patching strategies. Like sequential patching, parallel", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "patching is in the challenging setting where data from all patching tasks is not available simultaneously.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 680, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 677, + 467, + 693 + ], + "spans": [ + { + "bbox": [ + 118, + 677, + 467, + 693 + ], + "score": 1.0, + "content": "3The results are averaged over three random seeds that control the order in which tasks are seen.", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 118, + 688, + 461, + 703 + ], + "score": 1.0, + "content": "4We also explored adaptive black-box optimization algorithms to choose the mixing coefficients", + "type": "text" + }, + { + "bbox": [ + 461, + 692, + 471, + 700 + ], + "score": 0.84, + "content": "\\alpha _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 688, + 506, + 703 + ], + "score": 1.0, + "content": "[60], but", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 699, + 361, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 361, + 713 + ], + "score": 1.0, + "content": "observed little improvement (0.3 to 0.4 percentage points on average).", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 709, + 453, + 724 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 453, + 724 + ], + "score": 1.0, + "content": "5Recall from Section 3 that combined accuracy weight patching and supported tasks equally.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 74, + 501, + 184 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 74, + 501, + 184 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 74, + 501, + 184 + ], + "spans": [ + { + "bbox": [ + 109, + 74, + 501, + 184 + ], + "score": 0.961, + "type": "image", + "image_path": "4fadd75b187a9012519acf4b3f049b196caf35139ece0e9667ceb2b469c2d014.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 74, + 501, + 110.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 110.66666666666666, + 501, + 147.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 147.33333333333331, + 501, + 183.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 192, + 505, + 247 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 191, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 506, + 206 + ], + "score": 1.0, + "content": "Figure 4: Results are consistent across supported tasks. For multiple supported tasks, we observe", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "score": 1.0, + "content": "similar accuracy improvements on patching tasks, without substantially decreasing supported task", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 506, + 227 + ], + "score": 1.0, + "content": "accuracy. Additional results for the supported tasks Food101, STL10 and ImageNet are in Appendix", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 223, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 104, + 223, + 506, + 239 + ], + "score": 1.0, + "content": "F. Moreover, choosing the mixing coefficients using a different supported task does not substantially", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 235, + 383, + 249 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 383, + 249 + ], + "score": 1.0, + "content": "decrease combined accuracy on patching and supported tasks (right).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "title", + "bbox": [ + 107, + 259, + 300, + 273 + ], + "lines": [ + { + "bbox": [ + 105, + 259, + 301, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 301, + 276 + ], + "score": 1.0, + "content": "5 Patching models on multiple tasks", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 279, + 506, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "score": 1.0, + "content": "This section details experimental results for patching on multiple datasets. Recall from Section 2", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 290, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 506, + 303 + ], + "score": 1.0, + "content": "that there are various strategies for extending PAINT to multiple datasets, which we briefly revisit.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 300, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 505, + 315 + ], + "score": 1.0, + "content": "For joint patching we merge all the datasets into a single fine-tuning task and apply our patching", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 106, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "procedure as before. For sequential patching we iteratively perform our procedure once per task,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 322, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 506, + 335 + ], + "score": 1.0, + "content": "using the patched model at each step as the initialization for the next step.3 We also explore parallel", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 334, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 300, + 347 + ], + "score": 1.0, + "content": "patching, for which we have an unpatched model", + "type": "text" + }, + { + "bbox": [ + 300, + 334, + 313, + 345 + ], + "score": 0.88, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 334, + 506, + 347 + ], + "score": 1.0, + "content": "and independently fine-tune on each of the tasks", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 474, + 358 + ], + "score": 1.0, + "content": "in parallel. We then search for mixing coefficients to combine the resulting models. For tasks", + "type": "text" + }, + { + "bbox": [ + 474, + 345, + 502, + 357 + ], + "score": 0.91, + "content": "1 , . . . , k", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 345, + 506, + 358 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 101, + 353, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 101, + 353, + 143, + 376 + ], + "score": 1.0, + "content": "let θ(1)ft , .", + "type": "text" + }, + { + "bbox": [ + 120, + 356, + 169, + 371 + ], + "score": 0.93, + "content": "\\theta _ { \\mathrm { f t } } ^ { ( 1 ) } , . . . , \\theta _ { \\mathrm { f t } } ^ { ( k ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 354, + 505, + 375 + ], + "score": 1.0, + "content": "denote the fine-tuned models for each task. Since it is impractical to exhaustively", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 369, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 175, + 382 + ], + "score": 1.0, + "content": "search over each", + "type": "text" + }, + { + "bbox": [ + 176, + 371, + 186, + 380 + ], + "score": 0.84, + "content": "\\alpha _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 369, + 385, + 382 + ], + "score": 1.0, + "content": ", we instead search over a one-dimensional scalar", + "type": "text" + }, + { + "bbox": [ + 385, + 370, + 425, + 381 + ], + "score": 0.92, + "content": "\\alpha \\in [ 0 , 1 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 369, + 505, + 382 + ], + "score": 1.0, + "content": ", which interpolates", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 380, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 142, + 397 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 143, + 383, + 155, + 394 + ], + "score": 0.89, + "content": "\\theta _ { \\mathrm { z s } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 380, + 330, + 397 + ], + "score": 1.0, + "content": "and the average of all fine-tuned solutions", + "type": "text" + }, + { + "bbox": [ + 331, + 380, + 379, + 396 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\frac { 1 } { k } \\sum _ { i = 1 } ^ { k } \\theta _ { \\mathrm { f t } } ^ { ( i ) } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 380, + 505, + 397 + ], + "score": 1.0, + "content": ".4 Appendix J provides further", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 395, + 191, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 191, + 406 + ], + "score": 1.0, + "content": "experimental details.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14, + "bbox_fs": [ + 101, + 279, + 506, + 406 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 455 + ], + "lines": [ + { + "bbox": [ + 105, + 410, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 505, + 424 + ], + "score": 1.0, + "content": "These methods have various trade-offs and may be applicable for different scenarios. Joint patching", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "is only possible when data from all tasks you wish to patch is available. On the other hand, sequential", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 433, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 446 + ], + "score": 1.0, + "content": "patching is appropriate when the tasks are observed one after another. Finally, parallel patching can", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 444, + 229, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 229, + 456 + ], + "score": 1.0, + "content": "leverage distributed hardware.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 410, + 505, + 456 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 461, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "score": 1.0, + "content": "Figure 5 displays experimental results when patching on all nine tasks from Section 4. We observe", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "score": 1.0, + "content": "that joint patching is the best-performing method on average. This is perhaps unsurprising since", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "joint patching has simultaneous access to all patching datasets, unlike other patching strategies.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 494, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 505, + 506 + ], + "score": 1.0, + "content": "Nevertheless, it is still interesting that for ViT-L/14, joint patching yields a single model with only 0.5", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "percentage points worse combined accuracy than using multiple specialized models.5 Joint patching", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 529 + ], + "score": 1.0, + "content": "also achieves a 15.8 percentage points improvement over the unpatched model. Moreover, patching a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "ViT-B/32 model with the joint strategy achieves a combined accuracy 6.1 percentage points higher", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 537, + 386, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 307, + 549 + ], + "score": 1.0, + "content": "than a ViT-L/14 unpatched model, which requires", + "type": "text" + }, + { + "bbox": [ + 307, + 538, + 324, + 548 + ], + "score": 0.28, + "content": "1 2 \\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 537, + 386, + 549 + ], + "score": 1.0, + "content": "more GMACs.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5, + "bbox_fs": [ + 104, + 461, + 506, + 549 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 554, + 505, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "The accuracy of sequential patching approaches that of joint patching, especially for larger models.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "Note that, unlike in joint patching, forgetting can compound since the patching procedure is applied", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "multiple times in sequence. In sequential patching, weight interpolations do not completely eradicate", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 586, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 601 + ], + "score": 1.0, + "content": "forgetting, but greatly mitigate it. This is most noticeable for smaller models: sequentially fine-tuning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 611 + ], + "score": 1.0, + "content": "a ViT-B/32 without interpolation reduces the combined accuracy by 4.6 percentage points compared", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "to the unpatched model, as shown in Appendix J. This is compared to a combined accuracy increase", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "of 11 percentage points when using sequential patching. Additional results, including experiments on", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 631, + 293, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 293, + 643 + ], + "score": 1.0, + "content": "SplitCIFAR [61], can be found in Appendix J.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 554, + 506, + 643 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 648, + 505, + 671 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 661 + ], + "score": 1.0, + "content": "Finally, parallel patching underperforms other patching strategies. Like sequential patching, parallel", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "patching is in the challenging setting where data from all patching tasks is not available simultaneously.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 646, + 506, + 672 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 73, + 500, + 248 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 73, + 500, + 248 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 73, + 500, + 248 + ], + "spans": [ + { + "bbox": [ + 109, + 73, + 500, + 248 + ], + "score": 0.965, + "type": "image", + "image_path": "ab4c4ccd3a90497f1b687f69c948c94f7552f13a00a84ff2feb8d39fe792a1b1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 73, + 500, + 131.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 131.33333333333334, + 500, + 189.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 189.66666666666669, + 500, + 248.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 258, + 505, + 324 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "Figure 5: Contrasting various strategies for patching on multiple tasks. On all experiments,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 268, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 505, + 281 + ], + "score": 1.0, + "content": "ImageNet is used as the supported task while the other nine datasets are used for patching. When", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 279, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 505, + 293 + ], + "score": 1.0, + "content": "data from all patching tasks is available, joint patching yields a single model that is competitive with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 289, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 506, + 306 + ], + "score": 1.0, + "content": "using ten different specialized models. Weight interpolations greatly mitigate catastrophic forgetting", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 302, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 505, + 313 + ], + "score": 1.0, + "content": "on the sequential case, but do not completely eradicate it. Finally, parallel patching underperforms", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 311, + 446, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 446, + 325 + ], + "score": 1.0, + "content": "other patching strategies, but still provides improvements over the unpatched model.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + }, + { + "type": "table", + "bbox": [ + 107, + 326, + 504, + 381 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 326, + 504, + 381 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 326, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 107, + 326, + 504, + 381 + ], + "score": 0.968, + "html": "
CarsDTDEuroSATGTSRBKITTIMNISTRESISC45SUN397SVHN
Unpatched accuracy86.264.979.951.743.482.673.476.972.8
Patched accuracy87.0 (+0.8)66.1 (+1.2)87.2 (+7.3)71.1 (+19.4)60.4 (+17.0)91.3 (+8.7)74.2 (+0.8)79.3 (+2.4)88.9 (+16.1)
", + "type": "table", + "image_path": "b1b7945c0a9dae4162342796b36ab8d9a3bbc2e1486bcf37a2891a6e0877e091.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 107, + 326, + 504, + 344.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 107, + 344.3333333333333, + 504, + 362.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 107, + 362.66666666666663, + 504, + 380.99999999999994 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 495, + 399 + ], + "score": 1.0, + "content": "Table 1: PAINT can generalize to unseen classes. We randomly partition each dataset into tasks", + "type": "text" + }, + { + "bbox": [ + 495, + 387, + 504, + 396 + ], + "score": 0.67, + "content": "A", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 397, + 504, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 123, + 410 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 398, + 133, + 407 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 397, + 495, + 410 + ], + "score": 1.0, + "content": "with disjoint class spaces of roughly equal size. This table reports how patching on task", + "type": "text" + }, + { + "bbox": [ + 495, + 398, + 504, + 407 + ], + "score": 0.59, + "content": "A", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 204, + 420 + ], + "score": 1.0, + "content": "affects accuracy on task", + "type": "text" + }, + { + "bbox": [ + 204, + 408, + 213, + 418 + ], + "score": 0.77, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 408, + 431, + 420 + ], + "score": 1.0, + "content": "for the ViT-L/14 model. In all cases, accuracy on task", + "type": "text" + }, + { + "bbox": [ + 431, + 408, + 441, + 418 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "improves when", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 418, + 393, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 174, + 432 + ], + "score": 1.0, + "content": "patching on task", + "type": "text" + }, + { + "bbox": [ + 174, + 419, + 183, + 429 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 418, + 393, + 432 + ], + "score": 1.0, + "content": "even though the classes are unseen during patching.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 441, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 455 + ], + "score": 1.0, + "content": "Moreover, unlike in joint or sequential patching, no model is optimized on data from all patching", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 451, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 466 + ], + "score": 1.0, + "content": "tasks. Using a black box optimization algorithm for finding the mixing coefficients did not yield large", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "improvements over using the same mixing coefficient for all models. However, it is possible that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "more sophisticated search methods could yield better results. In Appendix J, we present additional", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "experiments for a subset of the tasks where exhaustively searching the space of mixing coefficients is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 496, + 346, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 346, + 508 + ], + "score": 1.0, + "content": "tractable, finding headroom for improvement in most cases.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 107, + 517, + 202, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 204, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 204, + 532 + ], + "score": 1.0, + "content": "6 Broad transfer", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 536, + 505, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "An alternative to our patching approach is to introduce parameters which are specific to each new", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "task. By contrast, PAINT always maintains a single model. This section describes an additional", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 558, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 376, + 571 + ], + "score": 1.0, + "content": "advantage of the single model approach: patching the model on task", + "type": "text" + }, + { + "bbox": [ + 377, + 558, + 385, + 568 + ], + "score": 0.65, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 558, + 506, + 571 + ], + "score": 1.0, + "content": "can improve accuracy on task", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 107, + 569, + 116, + 579 + ], + "score": 0.75, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 569, + 184, + 581 + ], + "score": 1.0, + "content": ", even when task", + "type": "text" + }, + { + "bbox": [ + 185, + 569, + 194, + 579 + ], + "score": 0.63, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 569, + 212, + 581 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 212, + 569, + 221, + 579 + ], + "score": 0.75, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "do not share the same classes. We refer to this phenomenon as broad", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 579, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 504, + 591 + ], + "score": 1.0, + "content": "transfer. Note that we are able to study this phenomenon because the single patched model remains", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "open-vocabulary throughout the patching procedure. This is a key advantage of PAINT compared to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 603, + 302, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 302, + 614 + ], + "score": 1.0, + "content": "maintaining a collection of task-specific models.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 618, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 372, + 630 + ], + "score": 1.0, + "content": "We now describe two experiments to measure the effects on a task", + "type": "text" + }, + { + "bbox": [ + 372, + 618, + 381, + 628 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 618, + 506, + 630 + ], + "score": 1.0, + "content": "when patching the model on a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 125, + 642 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 126, + 630, + 134, + 639 + ], + "score": 0.6, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 629, + 506, + 642 + ], + "score": 1.0, + "content": ". First, we explore broad transfer by randomly partitioning datasets into disjoint sets with no", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 640, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 217, + 652 + ], + "score": 1.0, + "content": "class overlap. For a dataset", + "type": "text" + }, + { + "bbox": [ + 218, + 640, + 227, + 650 + ], + "score": 0.8, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 640, + 340, + 652 + ], + "score": 1.0, + "content": "we partition the class space", + "type": "text" + }, + { + "bbox": [ + 340, + 640, + 349, + 650 + ], + "score": 0.8, + "content": "\\mathcal { V }", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 640, + 505, + 652 + ], + "score": 1.0, + "content": "into two disjoint sets of roughly equal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 650, + 504, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 124, + 663 + ], + "score": 1.0, + "content": "size", + "type": "text" + }, + { + "bbox": [ + 124, + 651, + 139, + 662 + ], + "score": 0.89, + "content": "\\mathcal { V } _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 650, + 156, + 663 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 157, + 651, + 171, + 662 + ], + "score": 0.88, + "content": "\\mathcal { { V } } _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 650, + 233, + 663 + ], + "score": 1.0, + "content": ". We build task", + "type": "text" + }, + { + "bbox": [ + 233, + 651, + 241, + 660 + ], + "score": 0.76, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 650, + 317, + 663 + ], + "score": 1.0, + "content": "with the examples", + "type": "text" + }, + { + "bbox": [ + 318, + 651, + 362, + 662 + ], + "score": 0.92, + "content": "( x , y ) \\in \\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 650, + 389, + 663 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 390, + 652, + 396, + 662 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 650, + 441, + 663 + ], + "score": 1.0, + "content": "belongs to", + "type": "text" + }, + { + "bbox": [ + 441, + 651, + 455, + 662 + ], + "score": 0.89, + "content": "\\mathcal { V } _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 650, + 494, + 663 + ], + "score": 1.0, + "content": ", and task", + "type": "text" + }, + { + "bbox": [ + 495, + 651, + 504, + 660 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 660, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 104, + 660, + 166, + 675 + ], + "score": 1.0, + "content": "with examples", + "type": "text" + }, + { + "bbox": [ + 166, + 662, + 190, + 673 + ], + "score": 0.92, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 660, + 217, + 675 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 218, + 663, + 225, + 673 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 660, + 269, + 675 + ], + "score": 1.0, + "content": "belongs to", + "type": "text" + }, + { + "bbox": [ + 269, + 662, + 283, + 673 + ], + "score": 0.87, + "content": "\\mathcal { { V } } _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 660, + 466, + 675 + ], + "score": 1.0, + "content": ". Table 1 shows how patching a model on task", + "type": "text" + }, + { + "bbox": [ + 467, + 662, + 475, + 672 + ], + "score": 0.75, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 660, + 506, + 675 + ], + "score": 1.0, + "content": "affects", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 189, + 686 + ], + "score": 1.0, + "content": "the accuracy on task", + "type": "text" + }, + { + "bbox": [ + 189, + 673, + 198, + 682 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 672, + 266, + 686 + ], + "score": 1.0, + "content": "for nine datasets", + "type": "text" + }, + { + "bbox": [ + 267, + 674, + 275, + 682 + ], + "score": 0.86, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 672, + 424, + 686 + ], + "score": 1.0, + "content": ". The accuracy improvements on task", + "type": "text" + }, + { + "bbox": [ + 424, + 673, + 433, + 682 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 672, + 506, + 686 + ], + "score": 1.0, + "content": "range from 0.8 to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 683, + 465, + 697 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 337, + 697 + ], + "score": 1.0, + "content": "19.4 percentage points, even though the classes from task", + "type": "text" + }, + { + "bbox": [ + 337, + 685, + 346, + 693 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 683, + 465, + 697 + ], + "score": 1.0, + "content": "are not seen during patching.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 366, + 712 + ], + "score": 1.0, + "content": "To further understand transfer, we consider additional task pairs", + "type": "text" + }, + { + "bbox": [ + 367, + 701, + 375, + 710 + ], + "score": 0.8, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 699, + 393, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 394, + 700, + 402, + 710 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 699, + 505, + 712 + ], + "score": 1.0, + "content": ", which are now different", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 216, + 724 + ], + "score": 1.0, + "content": "datasets. While some pairs", + "type": "text" + }, + { + "bbox": [ + 216, + 711, + 224, + 721 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 709, + 228, + 724 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 228, + 711, + 237, + 720 + ], + "score": 0.73, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "share classes, there are still instances of broad transfer. Concretely,", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 109, + 73, + 500, + 248 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 73, + 500, + 248 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 73, + 500, + 248 + ], + "spans": [ + { + "bbox": [ + 109, + 73, + 500, + 248 + ], + "score": 0.965, + "type": "image", + "image_path": "ab4c4ccd3a90497f1b687f69c948c94f7552f13a00a84ff2feb8d39fe792a1b1.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 109, + 73, + 500, + 131.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 131.33333333333334, + 500, + 189.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 109, + 189.66666666666669, + 500, + 248.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 258, + 505, + 324 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "Figure 5: Contrasting various strategies for patching on multiple tasks. On all experiments,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 268, + 505, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 505, + 281 + ], + "score": 1.0, + "content": "ImageNet is used as the supported task while the other nine datasets are used for patching. When", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 279, + 505, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 505, + 293 + ], + "score": 1.0, + "content": "data from all patching tasks is available, joint patching yields a single model that is competitive with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 289, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 506, + 306 + ], + "score": 1.0, + "content": "using ten different specialized models. Weight interpolations greatly mitigate catastrophic forgetting", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 302, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 505, + 313 + ], + "score": 1.0, + "content": "on the sequential case, but do not completely eradicate it. Finally, parallel patching underperforms", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 311, + 446, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 311, + 446, + 325 + ], + "score": 1.0, + "content": "other patching strategies, but still provides improvements over the unpatched model.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + } + ], + "index": 3.25 + }, + { + "type": "table", + "bbox": [ + 107, + 326, + 504, + 381 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 326, + 504, + 381 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 326, + 504, + 381 + ], + "spans": [ + { + "bbox": [ + 107, + 326, + 504, + 381 + ], + "score": 0.968, + "html": "
CarsDTDEuroSATGTSRBKITTIMNISTRESISC45SUN397SVHN
Unpatched accuracy86.264.979.951.743.482.673.476.972.8
Patched accuracy87.0 (+0.8)66.1 (+1.2)87.2 (+7.3)71.1 (+19.4)60.4 (+17.0)91.3 (+8.7)74.2 (+0.8)79.3 (+2.4)88.9 (+16.1)
", + "type": "table", + "image_path": "b1b7945c0a9dae4162342796b36ab8d9a3bbc2e1486bcf37a2891a6e0877e091.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 107, + 326, + 504, + 344.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 107, + 344.3333333333333, + 504, + 362.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 107, + 362.66666666666663, + 504, + 380.99999999999994 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 386, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 105, + 386, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 495, + 399 + ], + "score": 1.0, + "content": "Table 1: PAINT can generalize to unseen classes. We randomly partition each dataset into tasks", + "type": "text" + }, + { + "bbox": [ + 495, + 387, + 504, + 396 + ], + "score": 0.67, + "content": "A", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 397, + 504, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 123, + 410 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 124, + 398, + 133, + 407 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 397, + 495, + 410 + ], + "score": 1.0, + "content": "with disjoint class spaces of roughly equal size. This table reports how patching on task", + "type": "text" + }, + { + "bbox": [ + 495, + 398, + 504, + 407 + ], + "score": 0.59, + "content": "A", + "type": "inline_equation" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 204, + 420 + ], + "score": 1.0, + "content": "affects accuracy on task", + "type": "text" + }, + { + "bbox": [ + 204, + 408, + 213, + 418 + ], + "score": 0.77, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 408, + 431, + 420 + ], + "score": 1.0, + "content": "for the ViT-L/14 model. In all cases, accuracy on task", + "type": "text" + }, + { + "bbox": [ + 431, + 408, + 441, + 418 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "improves when", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 418, + 393, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 174, + 432 + ], + "score": 1.0, + "content": "patching on task", + "type": "text" + }, + { + "bbox": [ + 174, + 419, + 183, + 429 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 183, + 418, + 393, + 432 + ], + "score": 1.0, + "content": "even though the classes are unseen during patching.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 386, + 505, + 432 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 441, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 455 + ], + "score": 1.0, + "content": "Moreover, unlike in joint or sequential patching, no model is optimized on data from all patching", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 451, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 466 + ], + "score": 1.0, + "content": "tasks. Using a black box optimization algorithm for finding the mixing coefficients did not yield large", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "improvements over using the same mixing coefficient for all models. However, it is possible that", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "more sophisticated search methods could yield better results. In Appendix J, we present additional", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "experiments for a subset of the tasks where exhaustively searching the space of mixing coefficients is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 496, + 346, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 346, + 508 + ], + "score": 1.0, + "content": "tractable, finding headroom for improvement in most cases.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 440, + 506, + 508 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 517, + 202, + 531 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 204, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 204, + 532 + ], + "score": 1.0, + "content": "6 Broad transfer", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 536, + 505, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "An alternative to our patching approach is to introduce parameters which are specific to each new", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "task. By contrast, PAINT always maintains a single model. This section describes an additional", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 558, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 376, + 571 + ], + "score": 1.0, + "content": "advantage of the single model approach: patching the model on task", + "type": "text" + }, + { + "bbox": [ + 377, + 558, + 385, + 568 + ], + "score": 0.65, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 558, + 506, + 571 + ], + "score": 1.0, + "content": "can improve accuracy on task", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 107, + 569, + 116, + 579 + ], + "score": 0.75, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 569, + 184, + 581 + ], + "score": 1.0, + "content": ", even when task", + "type": "text" + }, + { + "bbox": [ + 185, + 569, + 194, + 579 + ], + "score": 0.63, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 194, + 569, + 212, + 581 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 212, + 569, + 221, + 579 + ], + "score": 0.75, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "do not share the same classes. We refer to this phenomenon as broad", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 579, + 504, + 591 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 504, + 591 + ], + "score": 1.0, + "content": "transfer. Note that we are able to study this phenomenon because the single patched model remains", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "open-vocabulary throughout the patching procedure. This is a key advantage of PAINT compared to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 603, + 302, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 302, + 614 + ], + "score": 1.0, + "content": "maintaining a collection of task-specific models.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 26, + "bbox_fs": [ + 106, + 536, + 506, + 614 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 618, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 506, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 372, + 630 + ], + "score": 1.0, + "content": "We now describe two experiments to measure the effects on a task", + "type": "text" + }, + { + "bbox": [ + 372, + 618, + 381, + 628 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 618, + 506, + 630 + ], + "score": 1.0, + "content": "when patching the model on a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 125, + 642 + ], + "score": 1.0, + "content": "task", + "type": "text" + }, + { + "bbox": [ + 126, + 630, + 134, + 639 + ], + "score": 0.6, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 629, + 506, + 642 + ], + "score": 1.0, + "content": ". First, we explore broad transfer by randomly partitioning datasets into disjoint sets with no", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 640, + 505, + 652 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 217, + 652 + ], + "score": 1.0, + "content": "class overlap. For a dataset", + "type": "text" + }, + { + "bbox": [ + 218, + 640, + 227, + 650 + ], + "score": 0.8, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 640, + 340, + 652 + ], + "score": 1.0, + "content": "we partition the class space", + "type": "text" + }, + { + "bbox": [ + 340, + 640, + 349, + 650 + ], + "score": 0.8, + "content": "\\mathcal { V }", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 640, + 505, + 652 + ], + "score": 1.0, + "content": "into two disjoint sets of roughly equal", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 650, + 504, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 124, + 663 + ], + "score": 1.0, + "content": "size", + "type": "text" + }, + { + "bbox": [ + 124, + 651, + 139, + 662 + ], + "score": 0.89, + "content": "\\mathcal { V } _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 650, + 156, + 663 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 157, + 651, + 171, + 662 + ], + "score": 0.88, + "content": "\\mathcal { { V } } _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 650, + 233, + 663 + ], + "score": 1.0, + "content": ". We build task", + "type": "text" + }, + { + "bbox": [ + 233, + 651, + 241, + 660 + ], + "score": 0.76, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 650, + 317, + 663 + ], + "score": 1.0, + "content": "with the examples", + "type": "text" + }, + { + "bbox": [ + 318, + 651, + 362, + 662 + ], + "score": 0.92, + "content": "( x , y ) \\in \\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 650, + 389, + 663 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 390, + 652, + 396, + 662 + ], + "score": 0.82, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 650, + 441, + 663 + ], + "score": 1.0, + "content": "belongs to", + "type": "text" + }, + { + "bbox": [ + 441, + 651, + 455, + 662 + ], + "score": 0.89, + "content": "\\mathcal { V } _ { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 650, + 494, + 663 + ], + "score": 1.0, + "content": ", and task", + "type": "text" + }, + { + "bbox": [ + 495, + 651, + 504, + 660 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 660, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 104, + 660, + 166, + 675 + ], + "score": 1.0, + "content": "with examples", + "type": "text" + }, + { + "bbox": [ + 166, + 662, + 190, + 673 + ], + "score": 0.92, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 660, + 217, + 675 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 218, + 663, + 225, + 673 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 660, + 269, + 675 + ], + "score": 1.0, + "content": "belongs to", + "type": "text" + }, + { + "bbox": [ + 269, + 662, + 283, + 673 + ], + "score": 0.87, + "content": "\\mathcal { { V } } _ { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 660, + 466, + 675 + ], + "score": 1.0, + "content": ". Table 1 shows how patching a model on task", + "type": "text" + }, + { + "bbox": [ + 467, + 662, + 475, + 672 + ], + "score": 0.75, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 660, + 506, + 675 + ], + "score": 1.0, + "content": "affects", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 672, + 506, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 189, + 686 + ], + "score": 1.0, + "content": "the accuracy on task", + "type": "text" + }, + { + "bbox": [ + 189, + 673, + 198, + 682 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 672, + 266, + 686 + ], + "score": 1.0, + "content": "for nine datasets", + "type": "text" + }, + { + "bbox": [ + 267, + 674, + 275, + 682 + ], + "score": 0.86, + "content": "\\mathcal { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 672, + 424, + 686 + ], + "score": 1.0, + "content": ". The accuracy improvements on task", + "type": "text" + }, + { + "bbox": [ + 424, + 673, + 433, + 682 + ], + "score": 0.8, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 672, + 506, + 686 + ], + "score": 1.0, + "content": "range from 0.8 to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 683, + 465, + 697 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 337, + 697 + ], + "score": 1.0, + "content": "19.4 percentage points, even though the classes from task", + "type": "text" + }, + { + "bbox": [ + 337, + 685, + 346, + 693 + ], + "score": 0.81, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 683, + 465, + 697 + ], + "score": 1.0, + "content": "are not seen during patching.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33, + "bbox_fs": [ + 104, + 618, + 506, + 697 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 366, + 712 + ], + "score": 1.0, + "content": "To further understand transfer, we consider additional task pairs", + "type": "text" + }, + { + "bbox": [ + 367, + 701, + 375, + 710 + ], + "score": 0.8, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 699, + 393, + 712 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 394, + 700, + 402, + 710 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 699, + 505, + 712 + ], + "score": 1.0, + "content": ", which are now different", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 709, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 216, + 724 + ], + "score": 1.0, + "content": "datasets. While some pairs", + "type": "text" + }, + { + "bbox": [ + 216, + 711, + 224, + 721 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 709, + 228, + 724 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 228, + 711, + 237, + 720 + ], + "score": 0.73, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 709, + 505, + 724 + ], + "score": 1.0, + "content": "share classes, there are still instances of broad transfer. Concretely,", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 699, + 505, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 69, + 505, + 135 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 69, + 505, + 135 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 69, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 107, + 69, + 505, + 135 + ], + "score": 0.939, + "html": "
Task A Task BMNIST SVHN SVHNMNISTRESISC45EuroSAT RESISC45MNIST EuroSAT FashionMNISTFashionMNISTGTSRB MNISTMTSD MTSD GTSRB
Unpatched accuracy58.676.4 71.060.267.776.419.3 50.6
Patched accuracy68.9 93.2 (+10.3) ） (+16.8)69.7 (-1.3)70.4 (+10.2)70.8 (+3.1)77.5 (+1.1)30.8 69.8 (+11.5) (+19.2)
", + "type": "table", + "image_path": "74e1ef3194d2e86f89d81b7c5d43b6d3ff0d39963db8ec0e8d0836f2286d38c9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 69, + 505, + 91.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 91.0, + 505, + 113.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 113.0, + 505, + 135.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 108, + 140, + 502, + 173 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 139, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 213, + 153 + ], + "score": 1.0, + "content": "Table 2: Patching on task", + "type": "text" + }, + { + "bbox": [ + 214, + 140, + 223, + 150 + ], + "score": 0.51, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 139, + 391, + 153 + ], + "score": 1.0, + "content": "can improve accuracy on a related task", + "type": "text" + }, + { + "bbox": [ + 391, + 141, + 400, + 150 + ], + "score": 0.66, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 139, + 478, + 153 + ], + "score": 1.0, + "content": ". For a pair of tasks", + "type": "text" + }, + { + "bbox": [ + 479, + 141, + 487, + 150 + ], + "score": 0.58, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 139, + 505, + 153 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 107, + 151, + 115, + 161 + ], + "score": 0.59, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 150, + 291, + 163 + ], + "score": 1.0, + "content": ", we report accuracy of the ViT-L/14 on task", + "type": "text" + }, + { + "bbox": [ + 291, + 151, + 300, + 161 + ], + "score": 0.69, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 150, + 391, + 163 + ], + "score": 1.0, + "content": ", after patching on task", + "type": "text" + }, + { + "bbox": [ + 392, + 151, + 400, + 161 + ], + "score": 0.6, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 150, + 505, + 163 + ], + "score": 1.0, + "content": ", finding improvements on", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 163, + 207, + 174 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 207, + 174 + ], + "score": 1.0, + "content": "seven out of eight cases.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 111, + 183, + 499, + 285 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 183, + 499, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 183, + 499, + 285 + ], + "spans": [ + { + "bbox": [ + 111, + 183, + 499, + 285 + ], + "score": 0.965, + "type": "image", + "image_path": "6e73f1e55022da3d02d7e4fcdb5448dcc6e048f006e9441361fb77781b3537fd.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 111, + 183, + 499, + 217.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 111, + 217.0, + 499, + 251.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 251.0, + 499, + 285.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 293, + 505, + 359 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Figure 6: Guarding against real-world typographic attacks by patching on synthetic data. (a) A", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 303, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 104, + 303, + 506, + 318 + ], + "score": 1.0, + "content": "sample from our real-world typographic attacks test set. A CLIP ViT-L/14 is “tricked” into classifying", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "this image as a dog instead of a cat. (b) Sample of synthetic typographic attack data. (c) Performance", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "on real-world data with unseen classes after patching on only synthetic typographic attacks (curves", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "score": 1.0, + "content": "produced by interpolating between the unpatched and fine-tuned model). (d) Analogous curves for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 308, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 308, + 362 + ], + "score": 1.0, + "content": "the test set of the synthetic data used for patching.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5 + } + ], + "index": 9.25 + }, + { + "type": "text", + "bbox": [ + 107, + 378, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 390 + ], + "score": 1.0, + "content": "Table 2 examines i) MNIST and SVHN, two digit recognition tasks with shared classes; ii) EuroSAT", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "score": 1.0, + "content": "and RESISC45, two satellite imagery recognition tasks where there are unshared classes but some", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 401, + 505, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 413 + ], + "score": 1.0, + "content": "overlap; iii) GTSRB and MTSD [17], two traffic sign recognition datasets where there are unshared", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "classes but some overlap; and iv) MNIST and FashionMNIST [83], which do not share any classes", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 421, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 104, + 421, + 419, + 436 + ], + "score": 1.0, + "content": "but appear visually similar. In seven out of eight experiments, patching on task", + "type": "text" + }, + { + "bbox": [ + 419, + 423, + 428, + 432 + ], + "score": 0.75, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 421, + 505, + 436 + ], + "score": 1.0, + "content": "improves accuracy", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 433, + 507, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 263, + 446 + ], + "score": 1.0, + "content": "by 1.1 to 19.2 percentage points on task", + "type": "text" + }, + { + "bbox": [ + 263, + 434, + 272, + 443 + ], + "score": 0.7, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 433, + 366, + 446 + ], + "score": 1.0, + "content": ". The exception is when", + "type": "text" + }, + { + "bbox": [ + 366, + 434, + 375, + 443 + ], + "score": 0.74, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 433, + 439, + 446 + ], + "score": 1.0, + "content": "is EuroSAT and", + "type": "text" + }, + { + "bbox": [ + 439, + 434, + 449, + 443 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 433, + 507, + 446 + ], + "score": 1.0, + "content": "is RESISC45,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 445, + 314, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 314, + 457 + ], + "score": 1.0, + "content": "where accuracy decreases by 1.3 percentage points.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 277, + 475 + ], + "score": 1.0, + "content": "In all experiments, when patching on task", + "type": "text" + }, + { + "bbox": [ + 277, + 463, + 286, + 472 + ], + "score": 0.58, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 462, + 422, + 475 + ], + "score": 1.0, + "content": "we choose the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 423, + 464, + 430, + 472 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "by optimizing the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 254, + 486 + ], + "score": 1.0, + "content": "held-out validation accuracy on task", + "type": "text" + }, + { + "bbox": [ + 255, + 474, + 264, + 484 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "and a supported task (in this experiment we use ImageNet).", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "While it is possible for a method that introduces new parameters for each task to exhibit broad transfer", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "to new data, this also requires knowing which parameters to apply for the new data. This is not", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 506, + 268, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 268, + 518 + ], + "score": 1.0, + "content": "necessary in the single model approach.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 189, + 542 + ], + "lines": [ + { + "bbox": [ + 104, + 527, + 190, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 527, + 190, + 545 + ], + "score": 1.0, + "content": "7 Case studies", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 108, + 550, + 504, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "score": 1.0, + "content": "We further examine the performance of PAINT in three additional settings, which highlight weak-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 560, + 415, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 415, + 573 + ], + "score": 1.0, + "content": "nesses of the zero-shot CLIP model and showcase broad transfer (Section 6).", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "Typographic attacks. Goh et al. [23] find that CLIP models are susceptible to typographic attacks,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 465, + 603 + ], + "score": 1.0, + "content": "where text superimposed on an image leads to misclassification. For example, in Figure", + "type": "text" + }, + { + "bbox": [ + 465, + 591, + 486, + 601 + ], + "score": 0.41, + "content": "6 ( a )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 589, + 505, + 603 + ], + "score": 1.0, + "content": ", the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "text on the pink note saying “dog” leads a CLIP to misclassify the image of a cat as a dog. To fix", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "this vulnerability, we procedurally generate typographic attack data by adding text with incorrect", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 623, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 309, + 635 + ], + "score": 1.0, + "content": "class names to SUN397 [84], as seen in Figure 6", + "type": "text" + }, + { + "bbox": [ + 309, + 623, + 322, + 634 + ], + "score": 0.27, + "content": "( b )", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 623, + 505, + 635 + ], + "score": 1.0, + "content": ". We then collect a test set of 110 real world", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 633, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 647 + ], + "score": 1.0, + "content": "images by placing notes on objects and taking photos.6 After applying PAINT using the synthetic", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 644, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 658 + ], + "score": 1.0, + "content": "data, we evaluate on the real-world images (Figure 6 (c)) and synthetic test set (Figure 6 (d)). We", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "observe that while larger models are more susceptible to typographic attacks, they are also more", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "amenable to patching. Furthermore, we see an example of broad transfer between the synthetic and", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "real-world data: when patching ViT-L/14 on synthetic data, its accuracy on real-world typographic", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 689, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 700 + ], + "score": 1.0, + "content": "attacks improves 41 percentage points even though the real-world classes are unseen. The cost is", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 712, + 381, + 722 + ], + "lines": [ + { + "bbox": [ + 119, + 709, + 382, + 724 + ], + "spans": [ + { + "bbox": [ + 119, + 709, + 382, + 724 + ], + "score": 1.0, + "content": "6Data available at https://github.com/mlfoundations/patching.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 107, + 69, + 505, + 135 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 107, + 69, + 505, + 135 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 69, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 107, + 69, + 505, + 135 + ], + "score": 0.939, + "html": "
Task A Task BMNIST SVHN SVHNMNISTRESISC45EuroSAT RESISC45MNIST EuroSAT FashionMNISTFashionMNISTGTSRB MNISTMTSD MTSD GTSRB
Unpatched accuracy58.676.4 71.060.267.776.419.3 50.6
Patched accuracy68.9 93.2 (+10.3) ） (+16.8)69.7 (-1.3)70.4 (+10.2)70.8 (+3.1)77.5 (+1.1)30.8 69.8 (+11.5) (+19.2)
", + "type": "table", + "image_path": "74e1ef3194d2e86f89d81b7c5d43b6d3ff0d39963db8ec0e8d0836f2286d38c9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 69, + 505, + 91.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 91.0, + 505, + 113.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 113.0, + 505, + 135.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 108, + 140, + 502, + 173 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 139, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 213, + 153 + ], + "score": 1.0, + "content": "Table 2: Patching on task", + "type": "text" + }, + { + "bbox": [ + 214, + 140, + 223, + 150 + ], + "score": 0.51, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 223, + 139, + 391, + 153 + ], + "score": 1.0, + "content": "can improve accuracy on a related task", + "type": "text" + }, + { + "bbox": [ + 391, + 141, + 400, + 150 + ], + "score": 0.66, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 139, + 478, + 153 + ], + "score": 1.0, + "content": ". For a pair of tasks", + "type": "text" + }, + { + "bbox": [ + 479, + 141, + 487, + 150 + ], + "score": 0.58, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 139, + 505, + 153 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 150, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 107, + 151, + 115, + 161 + ], + "score": 0.59, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 150, + 291, + 163 + ], + "score": 1.0, + "content": ", we report accuracy of the ViT-L/14 on task", + "type": "text" + }, + { + "bbox": [ + 291, + 151, + 300, + 161 + ], + "score": 0.69, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 150, + 391, + 163 + ], + "score": 1.0, + "content": ", after patching on task", + "type": "text" + }, + { + "bbox": [ + 392, + 151, + 400, + 161 + ], + "score": 0.6, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 150, + 505, + 163 + ], + "score": 1.0, + "content": ", finding improvements on", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 163, + 207, + 174 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 207, + 174 + ], + "score": 1.0, + "content": "seven out of eight cases.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 111, + 183, + 499, + 285 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 183, + 499, + 285 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 183, + 499, + 285 + ], + "spans": [ + { + "bbox": [ + 111, + 183, + 499, + 285 + ], + "score": 0.965, + "type": "image", + "image_path": "6e73f1e55022da3d02d7e4fcdb5448dcc6e048f006e9441361fb77781b3537fd.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 111, + 183, + 499, + 217.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 111, + 217.0, + 499, + 251.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 251.0, + 499, + 285.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 293, + 505, + 359 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 106, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Figure 6: Guarding against real-world typographic attacks by patching on synthetic data. (a) A", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 303, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 104, + 303, + 506, + 318 + ], + "score": 1.0, + "content": "sample from our real-world typographic attacks test set. A CLIP ViT-L/14 is “tricked” into classifying", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "this image as a dog instead of a cat. (b) Sample of synthetic typographic attack data. (c) Performance", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "on real-world data with unseen classes after patching on only synthetic typographic attacks (curves", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 506, + 349 + ], + "score": 1.0, + "content": "produced by interpolating between the unpatched and fine-tuned model). (d) Analogous curves for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 308, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 308, + 362 + ], + "score": 1.0, + "content": "the test set of the synthetic data used for patching.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11.5 + } + ], + "index": 9.25 + }, + { + "type": "text", + "bbox": [ + 107, + 378, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 506, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 506, + 390 + ], + "score": 1.0, + "content": "Table 2 examines i) MNIST and SVHN, two digit recognition tasks with shared classes; ii) EuroSAT", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "score": 1.0, + "content": "and RESISC45, two satellite imagery recognition tasks where there are unshared classes but some", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 401, + 505, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 413 + ], + "score": 1.0, + "content": "overlap; iii) GTSRB and MTSD [17], two traffic sign recognition datasets where there are unshared", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "classes but some overlap; and iv) MNIST and FashionMNIST [83], which do not share any classes", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 421, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 104, + 421, + 419, + 436 + ], + "score": 1.0, + "content": "but appear visually similar. In seven out of eight experiments, patching on task", + "type": "text" + }, + { + "bbox": [ + 419, + 423, + 428, + 432 + ], + "score": 0.75, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 421, + 505, + 436 + ], + "score": 1.0, + "content": "improves accuracy", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 433, + 507, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 263, + 446 + ], + "score": 1.0, + "content": "by 1.1 to 19.2 percentage points on task", + "type": "text" + }, + { + "bbox": [ + 263, + 434, + 272, + 443 + ], + "score": 0.7, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 433, + 366, + 446 + ], + "score": 1.0, + "content": ". The exception is when", + "type": "text" + }, + { + "bbox": [ + 366, + 434, + 375, + 443 + ], + "score": 0.74, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 433, + 439, + 446 + ], + "score": 1.0, + "content": "is EuroSAT and", + "type": "text" + }, + { + "bbox": [ + 439, + 434, + 449, + 443 + ], + "score": 0.82, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 433, + 507, + 446 + ], + "score": 1.0, + "content": "is RESISC45,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 445, + 314, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 314, + 457 + ], + "score": 1.0, + "content": "where accuracy decreases by 1.3 percentage points.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18, + "bbox_fs": [ + 104, + 378, + 507, + 457 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 277, + 475 + ], + "score": 1.0, + "content": "In all experiments, when patching on task", + "type": "text" + }, + { + "bbox": [ + 277, + 463, + 286, + 472 + ], + "score": 0.58, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 462, + 422, + 475 + ], + "score": 1.0, + "content": "we choose the mixing coefficient", + "type": "text" + }, + { + "bbox": [ + 423, + 464, + 430, + 472 + ], + "score": 0.77, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 431, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "by optimizing the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 254, + 486 + ], + "score": 1.0, + "content": "held-out validation accuracy on task", + "type": "text" + }, + { + "bbox": [ + 255, + 474, + 264, + 484 + ], + "score": 0.7, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "and a supported task (in this experiment we use ImageNet).", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 497 + ], + "score": 1.0, + "content": "While it is possible for a method that introduces new parameters for each task to exhibit broad transfer", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "to new data, this also requires knowing which parameters to apply for the new data. This is not", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 506, + 268, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 268, + 518 + ], + "score": 1.0, + "content": "necessary in the single model approach.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 462, + 506, + 518 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 529, + 189, + 542 + ], + "lines": [ + { + "bbox": [ + 104, + 527, + 190, + 545 + ], + "spans": [ + { + "bbox": [ + 104, + 527, + 190, + 545 + ], + "score": 1.0, + "content": "7 Case studies", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 108, + 550, + 504, + 572 + ], + "lines": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 561 + ], + "score": 1.0, + "content": "We further examine the performance of PAINT in three additional settings, which highlight weak-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 560, + 415, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 415, + 573 + ], + "score": 1.0, + "content": "nesses of the zero-shot CLIP model and showcase broad transfer (Section 6).", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 549, + 505, + 573 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 579, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "Typographic attacks. Goh et al. [23] find that CLIP models are susceptible to typographic attacks,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 589, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 465, + 603 + ], + "score": 1.0, + "content": "where text superimposed on an image leads to misclassification. For example, in Figure", + "type": "text" + }, + { + "bbox": [ + 465, + 591, + 486, + 601 + ], + "score": 0.41, + "content": "6 ( a )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 589, + 505, + 603 + ], + "score": 1.0, + "content": ", the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "text on the pink note saying “dog” leads a CLIP to misclassify the image of a cat as a dog. To fix", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 625 + ], + "score": 1.0, + "content": "this vulnerability, we procedurally generate typographic attack data by adding text with incorrect", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 623, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 309, + 635 + ], + "score": 1.0, + "content": "class names to SUN397 [84], as seen in Figure 6", + "type": "text" + }, + { + "bbox": [ + 309, + 623, + 322, + 634 + ], + "score": 0.27, + "content": "( b )", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 623, + 505, + 635 + ], + "score": 1.0, + "content": ". We then collect a test set of 110 real world", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 633, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 647 + ], + "score": 1.0, + "content": "images by placing notes on objects and taking photos.6 After applying PAINT using the synthetic", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 644, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 658 + ], + "score": 1.0, + "content": "data, we evaluate on the real-world images (Figure 6 (c)) and synthetic test set (Figure 6 (d)). We", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 668 + ], + "score": 1.0, + "content": "observe that while larger models are more susceptible to typographic attacks, they are also more", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "amenable to patching. Furthermore, we see an example of broad transfer between the synthetic and", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "real-world data: when patching ViT-L/14 on synthetic data, its accuracy on real-world typographic", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 689, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 700 + ], + "score": 1.0, + "content": "attacks improves 41 percentage points even though the real-world classes are unseen. The cost is", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "a reduction of less than 1 percentage point on ImageNet. We present details on the task and data", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 213, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 213, + 96 + ], + "score": 1.0, + "content": "collection in Appendix K.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 578, + 506, + 700 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 504, + 95 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "a reduction of less than 1 percentage point on ImageNet. We present details on the task and data", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 213, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 213, + 96 + ], + "score": 1.0, + "content": "collection in Appendix K.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 98, + 505, + 197 + ], + "lines": [ + { + "bbox": [ + 106, + 99, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 111 + ], + "score": 1.0, + "content": "Counting. Radford et al. [57] find that CLIP models struggle to count the number of objects in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 108, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 123 + ], + "score": 1.0, + "content": "CLEVR [32]. Here, the task is to choose an integer between 3 and 10 for each image, corresponding", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "to the number of visible objects. While a straightforward way to patch such a task is to fine-tune on it", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "directly, we investigate if applying PAINT using a subset of the classes allows the patched model", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "to generalize to other numbers. Specifically, we patch on images with 4, 5, 6, 8, or 9 objects. To", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "evaluate broad transfer, we test on images with 3, 7, and 10 objects (7 for understanding interpolation", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 164, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 420, + 176 + ], + "score": 1.0, + "content": "and 3 and 10 for extrapolation). We find that PAINT improves accuracy from", + "type": "text" + }, + { + "bbox": [ + 420, + 164, + 440, + 175 + ], + "score": 0.88, + "content": "59 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 164, + 471, + 176 + ], + "score": 1.0, + "content": "to over", + "type": "text" + }, + { + "bbox": [ + 471, + 164, + 491, + 175 + ], + "score": 0.87, + "content": "9 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 164, + 505, + 176 + ], + "score": 1.0, + "content": "o n", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 175, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 175, + 505, + 188 + ], + "score": 1.0, + "content": "unseen classes with less than half a percentage point decrease in ImageNet accuracy. For more details", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 186, + 174, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 174, + 199 + ], + "score": 1.0, + "content": "see Appendix L.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 201, + 505, + 311 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 214 + ], + "score": 1.0, + "content": "Visual question answering. As shown by Shen et al. [68], zero-shot CLIP models perform poorly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 212, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 224 + ], + "score": 1.0, + "content": "on visual question answering [4]. Using CLIP for VQA typically involves additional parameters—for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 222, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 506, + 235 + ], + "score": 1.0, + "content": "instance, Shen et al. [68] trains a transformer [77] on CLIP features. In contrast, our procedure for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 234, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 506, + 247 + ], + "score": 1.0, + "content": "patching CLIP on VQA does not introduce new parameters. Following Shen et al. [68], we contrast", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "images with a series of text prompts, where each prompt corresponds to an option in multiple-choice", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 255, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 506, + 268 + ], + "score": 1.0, + "content": "VQA, formed by both the question and a candidate answer using the following template: “Question:", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 267, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 279 + ], + "score": 1.0, + "content": "[question text] Answer: [answer text]”. We evaluate on multiple-choice VQA v1 [4], where each", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 277, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 505, + 291 + ], + "score": 1.0, + "content": "question is associated with 18 candidate answers. Our results, further detailed in Appendix M, show", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 288, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 505, + 301 + ], + "score": 1.0, + "content": "that patching is effective for visual question answering: PAINT improves the accuracy of a ViT-L/14", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 300, + 502, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 502, + 312 + ], + "score": 1.0, + "content": "model by 18 percentage points, while accuracy drops by less than one percentage point on ImageNet.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 107, + 321, + 194, + 334 + ], + "lines": [ + { + "bbox": [ + 104, + 319, + 196, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 196, + 336 + ], + "score": 1.0, + "content": "8 Related work", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 340, + 505, + 439 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "Continual learning and catastrophic forgetting. Learning tasks sequentially remains a challenge", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "for neural networks. When a neural network learns a new task, the accuracy on other tasks often", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 361, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 376 + ], + "score": 1.0, + "content": "decreases, a phenomenon known as catastrophic forgetting [48, 76, 20, 33]. While forgetting in", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "neural networks may actually aid learning [90], researchers have proposed various approaches for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 384, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 397 + ], + "score": 1.0, + "content": "alleviating catastrophic forgetting, including: i) Regularization-based approaches such as elastic", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 394, + 506, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 408 + ], + "score": 1.0, + "content": "weight consolidation (EWC) [33] and synaptic intelligence (SI) [87] which penalize the movement of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 405, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 418 + ], + "score": 1.0, + "content": "parameters and are related to weight-interpolation by Lubana et al. [44]; ii) Replay methods [61, 69,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "score": 1.0, + "content": "42, 6, 64, 50], which incorporate data or gradient information from previous tasks when learning a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 427, + 415, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 415, + 440 + ], + "score": 1.0, + "content": "new task; and iii) Introducing task-specific parameters [65, 85, 46, 8, 78, 80].", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "In contrast to these approaches, PAINT requires no modification to the standard fine-tuning process", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 455, + 506, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 506, + 467 + ], + "score": 1.0, + "content": "besides the later weight interpolation step. Moreover, unlike regularization or replay based methods,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "PAINT requires no extra computational cost during training. In contrast to methods with task specific", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "parameters, we maintain a single model. Having a single model is beneficial when there is new data", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 486, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 506, + 502 + ], + "score": 1.0, + "content": "which is similar to one of the tasks which have already been patched. Even without explicitly knowing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 498, + 481, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 481, + 511 + ], + "score": 1.0, + "content": "which task the new data is similar to, we can observe accuracy improvements (see Section 6).", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 515, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 506, + 528 + ], + "score": 1.0, + "content": "Similar to our work is that of Mirzadeh et al. [50], who observe high accuracy on task A on the linear", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 526, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 539 + ], + "score": 1.0, + "content": "path between a model which achieves high accuracy on task A and a model which is fine-tuned jointly", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "on task A and B. Moreover, they observe high accuracy on task B on the linear path between a model", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "fine-tuned on task B, and the jointly fine-tuned model. Therefore, there exists a path between a model", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "score": 1.0, + "content": "which achieves good performance on task A and a model fine-tuned on task B along which accuracy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 569, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 506, + 583 + ], + "score": 1.0, + "content": "is high on both tasks. However, in Mirzadeh et al. [50] this combined path can be non-linear, leading", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 579, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 595 + ], + "score": 1.0, + "content": "them to propose a regularization and replay based method. In our work, we find that examining", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "models on a linear path between the unpatched model (which has high accuracy on task A) and the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "score": 1.0, + "content": "model fine-tuned on task B is often sufficient for obtaining a model which achieves high accuracy", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "on both tasks (Figure 1). We speculate that this is due to scale and model architecture: in contrast", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "to Mirzadeh et al. [50], we initialize with a model pre-trained on a large dataset consisting of 400", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 635, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 647 + ], + "score": 1.0, + "content": "million images [57], and primarily use vision transformers [15]. As shown in Section 4.2, our method", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 646, + 460, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 460, + 658 + ], + "score": 1.0, + "content": "performs substantially worse with ResNets [24], which are used by Mirzadeh et al. [50].", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 108, + 663, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 662, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 505, + 676 + ], + "score": 1.0, + "content": "Finally, Ramasesh et al. [59] and Mehta et al. [49] also observed that catastrophic forgetting is less", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 674, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 506, + 685 + ], + "score": 1.0, + "content": "problematic for large and pre-trained models. In addition, Ramasesh et al. [59] found—similar to our", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 685, + 495, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 495, + 696 + ], + "score": 1.0, + "content": "results—that vision transformers are less susceptible to forgetting than ResNets of the same size.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51 + }, + { + "type": "text", + "bbox": [ + 106, + 700, + 502, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 504, + 712 + ], + "score": 1.0, + "content": "Linear mode connectivity and robust fine-tuning. Linearly interpolating neural network weights", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 710, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 504, + 723 + ], + "score": 1.0, + "content": "is a key step in PAINT. Because of the many nonlinear activations in a neural network, it is not clear", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 53.5 + } + ], + "page_idx": 8, + "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": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 73, + 504, + 95 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 72, + 505, + 96 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 98, + 505, + 197 + ], + "lines": [ + { + "bbox": [ + 106, + 99, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 111 + ], + "score": 1.0, + "content": "Counting. Radford et al. [57] find that CLIP models struggle to count the number of objects in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 108, + 506, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 123 + ], + "score": 1.0, + "content": "CLEVR [32]. Here, the task is to choose an integer between 3 and 10 for each image, corresponding", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 106, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "to the number of visible objects. While a straightforward way to patch such a task is to fine-tune on it", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 144 + ], + "score": 1.0, + "content": "directly, we investigate if applying PAINT using a subset of the classes allows the patched model", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "to generalize to other numbers. Specifically, we patch on images with 4, 5, 6, 8, or 9 objects. To", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "evaluate broad transfer, we test on images with 3, 7, and 10 objects (7 for understanding interpolation", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 164, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 420, + 176 + ], + "score": 1.0, + "content": "and 3 and 10 for extrapolation). We find that PAINT improves accuracy from", + "type": "text" + }, + { + "bbox": [ + 420, + 164, + 440, + 175 + ], + "score": 0.88, + "content": "59 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 164, + 471, + 176 + ], + "score": 1.0, + "content": "to over", + "type": "text" + }, + { + "bbox": [ + 471, + 164, + 491, + 175 + ], + "score": 0.87, + "content": "9 9 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 492, + 164, + 505, + 176 + ], + "score": 1.0, + "content": "o n", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 175, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 106, + 175, + 505, + 188 + ], + "score": 1.0, + "content": "unseen classes with less than half a percentage point decrease in ImageNet accuracy. For more details", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 186, + 174, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 174, + 199 + ], + "score": 1.0, + "content": "see Appendix L.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 99, + 506, + 199 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 201, + 505, + 311 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 505, + 214 + ], + "score": 1.0, + "content": "Visual question answering. As shown by Shen et al. [68], zero-shot CLIP models perform poorly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 212, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 224 + ], + "score": 1.0, + "content": "on visual question answering [4]. Using CLIP for VQA typically involves additional parameters—for", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 222, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 506, + 235 + ], + "score": 1.0, + "content": "instance, Shen et al. [68] trains a transformer [77] on CLIP features. In contrast, our procedure for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 234, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 506, + 247 + ], + "score": 1.0, + "content": "patching CLIP on VQA does not introduce new parameters. Following Shen et al. [68], we contrast", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 258 + ], + "score": 1.0, + "content": "images with a series of text prompts, where each prompt corresponds to an option in multiple-choice", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 255, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 506, + 268 + ], + "score": 1.0, + "content": "VQA, formed by both the question and a candidate answer using the following template: “Question:", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 267, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 279 + ], + "score": 1.0, + "content": "[question text] Answer: [answer text]”. We evaluate on multiple-choice VQA v1 [4], where each", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 277, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 505, + 291 + ], + "score": 1.0, + "content": "question is associated with 18 candidate answers. Our results, further detailed in Appendix M, show", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 288, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 505, + 301 + ], + "score": 1.0, + "content": "that patching is effective for visual question answering: PAINT improves the accuracy of a ViT-L/14", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 300, + 502, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 502, + 312 + ], + "score": 1.0, + "content": "model by 18 percentage points, while accuracy drops by less than one percentage point on ImageNet.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 200, + 506, + 312 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 321, + 194, + 334 + ], + "lines": [ + { + "bbox": [ + 104, + 319, + 196, + 336 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 196, + 336 + ], + "score": 1.0, + "content": "8 Related work", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 340, + 505, + 439 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "Continual learning and catastrophic forgetting. Learning tasks sequentially remains a challenge", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "for neural networks. When a neural network learns a new task, the accuracy on other tasks often", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 361, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 376 + ], + "score": 1.0, + "content": "decreases, a phenomenon known as catastrophic forgetting [48, 76, 20, 33]. While forgetting in", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "neural networks may actually aid learning [90], researchers have proposed various approaches for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 384, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 397 + ], + "score": 1.0, + "content": "alleviating catastrophic forgetting, including: i) Regularization-based approaches such as elastic", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 394, + 506, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 506, + 408 + ], + "score": 1.0, + "content": "weight consolidation (EWC) [33] and synaptic intelligence (SI) [87] which penalize the movement of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 405, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 418 + ], + "score": 1.0, + "content": "parameters and are related to weight-interpolation by Lubana et al. [44]; ii) Replay methods [61, 69,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "score": 1.0, + "content": "42, 6, 64, 50], which incorporate data or gradient information from previous tasks when learning a", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 427, + 415, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 415, + 440 + ], + "score": 1.0, + "content": "new task; and iii) Introducing task-specific parameters [65, 85, 46, 8, 78, 80].", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 339, + 506, + 440 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 444, + 505, + 510 + ], + "lines": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 505, + 457 + ], + "score": 1.0, + "content": "In contrast to these approaches, PAINT requires no modification to the standard fine-tuning process", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 455, + 506, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 506, + 467 + ], + "score": 1.0, + "content": "besides the later weight interpolation step. Moreover, unlike regularization or replay based methods,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "PAINT requires no extra computational cost during training. In contrast to methods with task specific", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "parameters, we maintain a single model. Having a single model is beneficial when there is new data", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 486, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 506, + 502 + ], + "score": 1.0, + "content": "which is similar to one of the tasks which have already been patched. Even without explicitly knowing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 498, + 481, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 481, + 511 + ], + "score": 1.0, + "content": "which task the new data is similar to, we can observe accuracy improvements (see Section 6).", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 444, + 506, + 511 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 515, + 505, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 506, + 528 + ], + "score": 1.0, + "content": "Similar to our work is that of Mirzadeh et al. [50], who observe high accuracy on task A on the linear", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 526, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 506, + 539 + ], + "score": 1.0, + "content": "path between a model which achieves high accuracy on task A and a model which is fine-tuned jointly", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "on task A and B. Moreover, they observe high accuracy on task B on the linear path between a model", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "fine-tuned on task B, and the jointly fine-tuned model. Therefore, there exists a path between a model", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "score": 1.0, + "content": "which achieves good performance on task A and a model fine-tuned on task B along which accuracy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 569, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 506, + 583 + ], + "score": 1.0, + "content": "is high on both tasks. However, in Mirzadeh et al. [50] this combined path can be non-linear, leading", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 579, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 595 + ], + "score": 1.0, + "content": "them to propose a regularization and replay based method. In our work, we find that examining", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 591, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 604 + ], + "score": 1.0, + "content": "models on a linear path between the unpatched model (which has high accuracy on task A) and the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 616 + ], + "score": 1.0, + "content": "model fine-tuned on task B is often sufficient for obtaining a model which achieves high accuracy", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 506, + 626 + ], + "score": 1.0, + "content": "on both tasks (Figure 1). We speculate that this is due to scale and model architecture: in contrast", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "to Mirzadeh et al. [50], we initialize with a model pre-trained on a large dataset consisting of 400", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 635, + 506, + 647 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 506, + 647 + ], + "score": 1.0, + "content": "million images [57], and primarily use vision transformers [15]. As shown in Section 4.2, our method", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 646, + 460, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 460, + 658 + ], + "score": 1.0, + "content": "performs substantially worse with ResNets [24], which are used by Mirzadeh et al. [50].", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 514, + 506, + 658 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 663, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 662, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 505, + 676 + ], + "score": 1.0, + "content": "Finally, Ramasesh et al. [59] and Mehta et al. [49] also observed that catastrophic forgetting is less", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 674, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 506, + 685 + ], + "score": 1.0, + "content": "problematic for large and pre-trained models. In addition, Ramasesh et al. [59] found—similar to our", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 685, + 495, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 495, + 696 + ], + "score": 1.0, + "content": "results—that vision transformers are less susceptible to forgetting than ResNets of the same size.", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51, + "bbox_fs": [ + 105, + 662, + 506, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 700, + 502, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 504, + 712 + ], + "score": 1.0, + "content": "Linear mode connectivity and robust fine-tuning. Linearly interpolating neural network weights", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 710, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 504, + 723 + ], + "score": 1.0, + "content": "is a key step in PAINT. Because of the many nonlinear activations in a neural network, it is not clear", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 73, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 506, + 85 + ], + "score": 1.0, + "content": "a priori that linearly interpolating between two sets of weights can result in a high accuracy solution.", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "However, researchers have observed that interpolating neural network weights can achieve high", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "score": 1.0, + "content": "accuracy when training on MNIST from a common initialization [52] or when part of the optimization", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "trajectory is shared [19, 28, 54, 18, 82, 47, 16, 81, 10]. The term linear mode connectivity was coined", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "by Frankle et al. [19]: two networks exhibit linearly mode connectivity if the accuracy does not", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "score": 1.0, + "content": "decrease when using weights on the linear path between them [52, 19]. Weight averaging for continual", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 138, + 423, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 423, + 151 + ], + "score": 1.0, + "content": "learning has also been studied by Lee et al. [40] for closed-vocabulary models.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + } + ], + "index": 53.5, + "bbox_fs": [ + 105, + 699, + 504, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 73, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 506, + 85 + ], + "score": 1.0, + "content": "a priori that linearly interpolating between two sets of weights can result in a high accuracy solution.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "However, researchers have observed that interpolating neural network weights can achieve high", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "score": 1.0, + "content": "accuracy when training on MNIST from a common initialization [52] or when part of the optimization", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "trajectory is shared [19, 28, 54, 18, 82, 47, 16, 81, 10]. The term linear mode connectivity was coined", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 505, + 128 + ], + "score": 1.0, + "content": "by Frankle et al. [19]: two networks exhibit linearly mode connectivity if the accuracy does not", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "score": 1.0, + "content": "decrease when using weights on the linear path between them [52, 19]. Weight averaging for continual", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 138, + 423, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 423, + 151 + ], + "score": 1.0, + "content": "learning has also been studied by Lee et al. [40] for closed-vocabulary models.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 155, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "While Nagarajan and Kolter [52] and Frankle et al. [19] focused on accuracy on a single task, Worts-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "man et al. [82] use linear mode connectivity to fine-tune models while preserving their robustness to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "natural distribution shifts. By interpolating the weights of a zero-shot and fine-tuned model, they find", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "score": 1.0, + "content": "a solution which performs well both on the fine-tuning task and under distribution shift. In contrast to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "Wortsman et al. [82], we do not modify any task-specific parameters when fine-tuning, preserving the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "open-vocabulary nature of the models we patch. Unlike Wortsman et al. [82], we examine accuracy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 221, + 498, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 498, + 232 + ], + "score": 1.0, + "content": "trade-offs across different tasks with little or no class overlap and adapt a model to multiple tasks.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 237, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 249 + ], + "score": 1.0, + "content": "In addition, closely related to our work is that of Matena and Raffel [47], who use Fisher-weighted", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 247, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 259 + ], + "score": 1.0, + "content": "averaging of language models before and after fine-tuning on downstream tasks. Unlike Fisher-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "weighted averaging of Matena and Raffel [47], we do not use different mixing coefficients for each", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "score": 1.0, + "content": "parameter, and thus require no extra compute when patching. Moreover, we explore new strategies", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 281, + 485, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 485, + 293 + ], + "score": 1.0, + "content": "for patching on multiple tasks (see Section 5), and focus on open-vocabulary image classifiers.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 295, + 505, + 438 + ], + "lines": [ + { + "bbox": [ + 106, + 295, + 504, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 295, + 504, + 307 + ], + "score": 1.0, + "content": "Interventions to change the behavior of a trained model. Several authors have studied the problem", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 306, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 320 + ], + "score": 1.0, + "content": "of updating a model to locally alter its behavior on certain inputs without external disruptions on", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "other inputs [70, 13, 51, 66, 63, 62]. Previous literature uses various terms to refer to this process,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 327, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 505, + 342 + ], + "score": 1.0, + "content": "including model editing, patching or debugging. A popular use case is to update trained language", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "models to reflect changes in the world (for instance, facts like who is the current president of Brazil)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "[29, 45, 38, 30]. Moreover, inspired by software engineering practice, previous work explored", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 359, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 104, + 359, + 506, + 375 + ], + "score": 1.0, + "content": "“debugging” language models through user interaction [63, 62], including providing corrective", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 370, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 370, + 506, + 385 + ], + "score": 1.0, + "content": "feedback to the models via natural language [3]. Mitchell et al. [51], De Cao et al. [13] propose", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "training auxiliary networks to perform local edits on pre-trained models. Santurkar et al. [66]", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "introduce a method for rewriting the prediction rules of a classifier, focusing on specific failure modes", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "score": 1.0, + "content": "such as reliance on spurious correlations. In contrast with previous literature, our work explores", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 415, + 507, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 507, + 429 + ], + "score": 1.0, + "content": "patching models at the task level, aiming to systemically improve accuracy on a dataset—for instance,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 426, + 448, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 448, + 439 + ], + "score": 1.0, + "content": "enabling a model to recognize dozens of satellite imagery classes with a single patch.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 264, + 461 + ], + "lines": [ + { + "bbox": [ + 104, + 446, + 265, + 463 + ], + "spans": [ + { + "bbox": [ + 104, + 446, + 265, + 463 + ], + "score": 1.0, + "content": "9 Limitations and conclusion", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 468, + 505, + 533 + ], + "lines": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "score": 1.0, + "content": "Limitations. When applying PAINT, accuracy on supported tasks can still decrease, especially for", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "smaller models. This limitation is perhaps best reflected in the case of sequential patching: patched", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "models underperform using multiple specialized models when many tasks are added sequentially.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 500, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 506, + 513 + ], + "score": 1.0, + "content": "Using larger models and weight interpolations can alleviate this issue, but do not completely resolve", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "it. Finally, better understanding on which datasets patching is more effective is an exciting direction", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 522, + 185, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 185, + 533 + ], + "score": 1.0, + "content": "for future research.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 538, + 505, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 538, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 552 + ], + "score": 1.0, + "content": "Conclusion. In this work, we explore several techniques for patching open-vocabulary models with", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "the goal of improving accuracy on new tasks without decreasing accuracy elsewhere. PAINT is", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 560, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 506, + 573 + ], + "score": 1.0, + "content": "effective in several scenarios, ranging from classifying digits to defending against typographic attacks.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 570, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 585 + ], + "score": 1.0, + "content": "PAINT becomes more effective with scale, and can be applied on multiple tasks sequentially or", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "simultaneously. Our findings demonstrate that in many circumstances it is possible to expand the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "set of tasks on which models achieve high accuracy, without introducing new parameters, without", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 604, + 373, + 618 + ], + "spans": [ + { + "bbox": [ + 104, + 604, + 373, + 618 + ], + "score": 1.0, + "content": "re-training them from scratch, and without catastrophic forgetting.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42 + }, + { + "type": "title", + "bbox": [ + 108, + 626, + 201, + 639 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 203, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 203, + 641 + ], + "score": 1.0, + "content": "Acknowledgments", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "We thank Akari Asai, Alex Fang, David Fleet, Huy Ha, Ari Holtzman, Pieter-Jan Kindermans, Marco", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "Tulio Ribeiro, Ofir Press, Sarah Pratt, Sewon Min, Thao Nguyen and Tim Dettmers for helpful", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "discussions and feedback, and Hyak at UW for computing support. This work is in part supported", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "by the NSF AI Institute for Foundations of Machine Learning (IFML), Open Philanthropy, NSF", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "IIS 1652052, NSF IIS 17303166, NSF IIS 2044660, NSF IIS 2132519, ONR N00014-18-1-2826,", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 104, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "DARPA N66001-19-2-4031, DARPA W911NF-15-1-0543, the Sloan Fellowship and gifts from Allen", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 711, + 171, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 171, + 722 + ], + "score": 1.0, + "content": "Institute for AI.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 50 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 301, + 742, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 73, + 505, + 149 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 105, + 73, + 506, + 151 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 155, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "While Nagarajan and Kolter [52] and Frankle et al. [19] focused on accuracy on a single task, Worts-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "man et al. [82] use linear mode connectivity to fine-tune models while preserving their robustness to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 189 + ], + "score": 1.0, + "content": "natural distribution shifts. By interpolating the weights of a zero-shot and fine-tuned model, they find", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "score": 1.0, + "content": "a solution which performs well both on the fine-tuning task and under distribution shift. In contrast to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 211 + ], + "score": 1.0, + "content": "Wortsman et al. [82], we do not modify any task-specific parameters when fine-tuning, preserving the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "open-vocabulary nature of the models we patch. Unlike Wortsman et al. [82], we examine accuracy", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 221, + 498, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 498, + 232 + ], + "score": 1.0, + "content": "trade-offs across different tasks with little or no class overlap and adapt a model to multiple tasks.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 154, + 506, + 232 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 237, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 249 + ], + "score": 1.0, + "content": "In addition, closely related to our work is that of Matena and Raffel [47], who use Fisher-weighted", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 247, + 506, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 259 + ], + "score": 1.0, + "content": "averaging of language models before and after fine-tuning on downstream tasks. Unlike Fisher-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "weighted averaging of Matena and Raffel [47], we do not use different mixing coefficients for each", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 506, + 283 + ], + "score": 1.0, + "content": "parameter, and thus require no extra compute when patching. Moreover, we explore new strategies", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 281, + 485, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 485, + 293 + ], + "score": 1.0, + "content": "for patching on multiple tasks (see Section 5), and focus on open-vocabulary image classifiers.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 237, + 506, + 293 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 295, + 505, + 438 + ], + "lines": [ + { + "bbox": [ + 106, + 295, + 504, + 307 + ], + "spans": [ + { + "bbox": [ + 106, + 295, + 504, + 307 + ], + "score": 1.0, + "content": "Interventions to change the behavior of a trained model. Several authors have studied the problem", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 306, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 505, + 320 + ], + "score": 1.0, + "content": "of updating a model to locally alter its behavior on certain inputs without external disruptions on", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "other inputs [70, 13, 51, 66, 63, 62]. Previous literature uses various terms to refer to this process,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 327, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 505, + 342 + ], + "score": 1.0, + "content": "including model editing, patching or debugging. A popular use case is to update trained language", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "models to reflect changes in the world (for instance, facts like who is the current president of Brazil)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 349, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 506, + 363 + ], + "score": 1.0, + "content": "[29, 45, 38, 30]. Moreover, inspired by software engineering practice, previous work explored", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 359, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 104, + 359, + 506, + 375 + ], + "score": 1.0, + "content": "“debugging” language models through user interaction [63, 62], including providing corrective", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 370, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 370, + 506, + 385 + ], + "score": 1.0, + "content": "feedback to the models via natural language [3]. Mitchell et al. [51], De Cao et al. [13] propose", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "training auxiliary networks to perform local edits on pre-trained models. Santurkar et al. [66]", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "introduce a method for rewriting the prediction rules of a classifier, focusing on specific failure modes", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "score": 1.0, + "content": "such as reliance on spurious correlations. In contrast with previous literature, our work explores", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 415, + 507, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 507, + 429 + ], + "score": 1.0, + "content": "patching models at the task level, aiming to systemically improve accuracy on a dataset—for instance,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 426, + 448, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 448, + 439 + ], + "score": 1.0, + "content": "enabling a model to recognize dozens of satellite imagery classes with a single patch.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 25, + "bbox_fs": [ + 104, + 295, + 507, + 439 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 264, + 461 + ], + "lines": [ + { + "bbox": [ + 104, + 446, + 265, + 463 + ], + "spans": [ + { + "bbox": [ + 104, + 446, + 265, + 463 + ], + "score": 1.0, + "content": "9 Limitations and conclusion", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 468, + 505, + 533 + ], + "lines": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "score": 1.0, + "content": "Limitations. When applying PAINT, accuracy on supported tasks can still decrease, especially for", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "smaller models. This limitation is perhaps best reflected in the case of sequential patching: patched", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "models underperform using multiple specialized models when many tasks are added sequentially.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 500, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 506, + 513 + ], + "score": 1.0, + "content": "Using larger models and weight interpolations can alleviate this issue, but do not completely resolve", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "it. Finally, better understanding on which datasets patching is more effective is an exciting direction", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 522, + 185, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 185, + 533 + ], + "score": 1.0, + "content": "for future research.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 467, + 506, + 533 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 538, + 505, + 615 + ], + "lines": [ + { + "bbox": [ + 106, + 538, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 552 + ], + "score": 1.0, + "content": "Conclusion. In this work, we explore several techniques for patching open-vocabulary models with", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "the goal of improving accuracy on new tasks without decreasing accuracy elsewhere. PAINT is", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 560, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 506, + 573 + ], + "score": 1.0, + "content": "effective in several scenarios, ranging from classifying digits to defending against typographic attacks.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 570, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 585 + ], + "score": 1.0, + "content": "PAINT becomes more effective with scale, and can be applied on multiple tasks sequentially or", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "simultaneously. Our findings demonstrate that in many circumstances it is possible to expand the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "set of tasks on which models achieve high accuracy, without introducing new parameters, without", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 104, + 604, + 373, + 618 + ], + "spans": [ + { + "bbox": [ + 104, + 604, + 373, + 618 + ], + "score": 1.0, + "content": "re-training them from scratch, and without catastrophic forgetting.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 42, + "bbox_fs": [ + 104, + 538, + 506, + 618 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 626, + 201, + 639 + ], + "lines": [ + { + "bbox": [ + 106, + 624, + 203, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 203, + 641 + ], + "score": 1.0, + "content": "Acknowledgments", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 658 + ], + "score": 1.0, + "content": "We thank Akari Asai, Alex Fang, David Fleet, Huy Ha, Ari Holtzman, Pieter-Jan Kindermans, Marco", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "Tulio Ribeiro, Ofir Press, Sarah Pratt, Sewon Min, Thao Nguyen and Tim Dettmers for helpful", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 680 + ], + "score": 1.0, + "content": "discussions and feedback, and Hyak at UW for computing support. This work is in part supported", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "by the NSF AI Institute for Foundations of Machine Learning (IFML), Open Philanthropy, NSF", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "IIS 1652052, NSF IIS 17303166, NSF IIS 2044660, NSF IIS 2132519, ONR N00014-18-1-2826,", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 104, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "DARPA N66001-19-2-4031, DARPA W911NF-15-1-0543, the Sloan Fellowship and gifts from Allen", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 711, + 171, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 171, + 722 + ], + "score": 1.0, + "content": "Institute for AI.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 50, + "bbox_fs": [ + 104, + 645, + 506, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 64, + 507, + 730 + ], + "lines": [ + { + "bbox": [ + 105, + 68, + 167, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 68, + 167, + 87 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 109, + 87, + 507, + 102 + ], + "spans": [ + { + "bbox": [ + 109, + 87, + 507, + 102 + ], + "score": 1.0, + "content": "[1] Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 98, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 127, + 98, + 506, + 113 + ], + "score": 1.0, + "content": "Karel Lenc, Arthur Mensch, Katie Millican, Malcolm Reynolds, et al. Flamingo: a visual", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 111, + 480, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 111, + 480, + 124 + ], + "score": 1.0, + "content": "language model for few-shot learning, 2022. https://arxiv.org/abs/2204.14198.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 110, + 129, + 505, + 143 + ], + "spans": [ + { + "bbox": [ + 110, + 129, + 505, + 143 + ], + "score": 1.0, + "content": "[2] Anders Andreassen, Yasaman Bahri, Behnam Neyshabur, and Rebecca Roelofs. The evolution", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 126, + 140, + 504, + 154 + ], + "spans": [ + { + "bbox": [ + 126, + 140, + 504, + 154 + ], + "score": 1.0, + "content": "of out-of-distribution robustness throughout fine-tuning, 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 149, + 185, + 165 + ], + "spans": [ + { + "bbox": [ + 127, + 149, + 185, + 165 + ], + "score": 1.0, + "content": "2106.15831.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 110, + 168, + 506, + 182 + ], + "spans": [ + { + "bbox": [ + 110, + 168, + 506, + 182 + ], + "score": 1.0, + "content": "[3] Anonymous. Fixing model bugs with natural language patches, 2022. https://openreview.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 181, + 259, + 192 + ], + "spans": [ + { + "bbox": [ + 127, + 181, + 259, + 192 + ], + "score": 1.0, + "content": "net/forum?id=blJrg3WvvDV.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 110, + 199, + 506, + 213 + ], + "spans": [ + { + "bbox": [ + 110, + 199, + 506, + 213 + ], + "score": 1.0, + "content": "[4] Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 126, + 209, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 126, + 209, + 506, + 224 + ], + "score": 1.0, + "content": "Zitnick, and Devi Parikh. VQA: Visual Question Answering. In International Conference on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 221, + 429, + 235 + ], + "spans": [ + { + "bbox": [ + 127, + 221, + 429, + 235 + ], + "score": 1.0, + "content": "Computer Vision (ICCV), 2015. https://arxiv.org/abs/1505.00468.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 110, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 110, + 239, + 506, + 253 + ], + "score": 1.0, + "content": "[5] Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101–mining discriminative", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 250, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 127, + 250, + 506, + 264 + ], + "score": 1.0, + "content": "components with random forests. In European Conference on Computer Vision (ECCV), 2014.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 261, + 459, + 274 + ], + "spans": [ + { + "bbox": [ + 126, + 261, + 459, + 274 + ], + "score": 1.0, + "content": "https://link.springer.com/chapter/10.1007/978-3-319-10599-4_29.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 110, + 280, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 110, + 280, + 506, + 293 + ], + "score": 1.0, + "content": "[6] Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 290, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 126, + 290, + 506, + 305 + ], + "score": 1.0, + "content": "lifelong learning with a-gem. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 126, + 300, + 327, + 317 + ], + "spans": [ + { + "bbox": [ + 126, + 300, + 327, + 317 + ], + "score": 1.0, + "content": "2019. https://arxiv.org/abs/1812.00420.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 110, + 320, + 507, + 334 + ], + "spans": [ + { + "bbox": [ + 110, + 320, + 507, + 334 + ], + "score": 1.0, + "content": "[7] Gong Cheng, Junwei Han, and Xiaoqiang Lu. Remote sensing image scene classification:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 331, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 127, + 331, + 506, + 345 + ], + "score": 1.0, + "content": "Benchmark and state of the art. Proceedings of the Institute of Electrical and Electronics Engi-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 342, + 493, + 356 + ], + "spans": [ + { + "bbox": [ + 126, + 342, + 493, + 356 + ], + "score": 1.0, + "content": "neers (IEEE), 2017. https://ieeexplore.ieee.org/abstract/document/7891544.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 110, + 360, + 508, + 376 + ], + "spans": [ + { + "bbox": [ + 110, + 360, + 508, + 376 + ], + "score": 1.0, + "content": "[8] Brian Cheung, Alexander Terekhov, Yubei Chen, Pulkit Agrawal, and Bruno Olshausen.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 128, + 373, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 128, + 373, + 506, + 385 + ], + "score": 1.0, + "content": "Superposition of many models into one. In Advances in Neural Information Process-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 382, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 126, + 382, + 505, + 398 + ], + "score": 1.0, + "content": "ing Systems (NeurIPS), 2019. https://proceedings.neurips.cc/paper/2019/file/", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 393, + 353, + 407 + ], + "spans": [ + { + "bbox": [ + 126, + 393, + 353, + 407 + ], + "score": 1.0, + "content": "4c7a167bb329bd92580a99ce422d6fa6-Paper.pdf.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 110, + 411, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 110, + 411, + 506, + 427 + ], + "score": 1.0, + "content": "[9] Lenaic Chizat, Edouard Oyallon, and Francis Bach. On lazy training in dif-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 423, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 126, + 423, + 243, + 438 + ], + "score": 1.0, + "content": "ferentiable programming.", + "type": "text" + }, + { + "bbox": [ + 255, + 424, + 506, + 437 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 434, + 504, + 448 + ], + "spans": [ + { + "bbox": [ + 126, + 434, + 213, + 448 + ], + "score": 1.0, + "content": "(NeurIPS), 2019.", + "type": "text" + }, + { + "bbox": [ + 256, + 434, + 504, + 448 + ], + "score": 1.0, + "content": "https://proceedings.neurips.cc/paper/2019/file/", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 444, + 353, + 459 + ], + "spans": [ + { + "bbox": [ + 127, + 444, + 353, + 459 + ], + "score": 1.0, + "content": "ae614c557843b1df326cb29c57225459-Paper.pdf.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 464, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 506, + 478 + ], + "score": 1.0, + "content": "[10] Leshem Choshen, Elad Venezian, Noam Slonim, and Yoav Katz. Fusing finetuned models for", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 474, + 399, + 488 + ], + "spans": [ + { + "bbox": [ + 126, + 474, + 399, + 488 + ], + "score": 1.0, + "content": "better pretraining, 2022. https://arxiv.org/abs/2204.03044.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 492, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 104, + 492, + 506, + 507 + ], + "score": 1.0, + "content": "[11] Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 127, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "Describing textures in the wild. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 126, + 514, + 504, + 529 + ], + "spans": [ + { + "bbox": [ + 126, + 514, + 504, + 529 + ], + "score": 1.0, + "content": "(CVPR), 2014. https://openaccess.thecvf.com/content_cvpr_2014/html/Cimpoi_", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 126, + 525, + 357, + 540 + ], + "spans": [ + { + "bbox": [ + 126, + 525, + 357, + 540 + ], + "score": 1.0, + "content": "Describing_Textures_in_2014_CVPR_paper.html.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "score": 1.0, + "content": "[12] Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsu-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 127, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "pervised feature learning. In International Conference on Artificial Intelligence and Statistics", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 567, + 455, + 581 + ], + "spans": [ + { + "bbox": [ + 127, + 567, + 455, + 581 + ], + "score": 1.0, + "content": "(AISTATS), 2011. https://proceedings.mlr.press/v15/coates11a.html.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 585, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 506, + 599 + ], + "score": 1.0, + "content": "[13] Nicola De Cao, Wilker Aziz, and Ivan Titov. Editing factual knowledge in language models. In", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 125, + 595, + 507, + 611 + ], + "spans": [ + { + "bbox": [ + 125, + 595, + 507, + 611 + ], + "score": 1.0, + "content": "Conference on Empirical Methods in Natural Language Processing (EMNLP), 2021. https:", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 607, + 268, + 621 + ], + "spans": [ + { + "bbox": [ + 127, + 607, + 268, + 621 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2104.08164.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 625, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 625, + 506, + 639 + ], + "score": 1.0, + "content": "[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 126, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "hierarchical image database. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 126, + 648, + 471, + 662 + ], + "spans": [ + { + "bbox": [ + 126, + 648, + 471, + 662 + ], + "score": 1.0, + "content": "(CVPR), 2009. https://ieeexplore.ieee.org/abstract/document/5206848.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "[15] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 126, + 675, + 507, + 693 + ], + "spans": [ + { + "bbox": [ + 126, + 675, + 507, + 693 + ], + "score": 1.0, + "content": "Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 126, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 126, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 126, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 126, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "recognition at scale. In International Conference on Learning Representations, 2021. URL", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 126, + 710, + 353, + 724 + ], + "spans": [ + { + "bbox": [ + 126, + 710, + 353, + 724 + ], + "score": 1.0, + "content": "https://openreview.net/forum?id=YicbFdNTTy.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 24 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 310, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 755 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 755 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 106, + 64, + 507, + 730 + ], + "lines": [ + { + "bbox": [ + 105, + 68, + 167, + 87 + ], + "spans": [ + { + "bbox": [ + 105, + 68, + 167, + 87 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 109, + 87, + 507, + 102 + ], + "spans": [ + { + "bbox": [ + 109, + 87, + 507, + 102 + ], + "score": 1.0, + "content": "[1] Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson,", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 98, + 506, + 113 + ], + "spans": [ + { + "bbox": [ + 127, + 98, + 506, + 113 + ], + "score": 1.0, + "content": "Karel Lenc, Arthur Mensch, Katie Millican, Malcolm Reynolds, et al. Flamingo: a visual", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 111, + 480, + 124 + ], + "spans": [ + { + "bbox": [ + 127, + 111, + 480, + 124 + ], + "score": 1.0, + "content": "language model for few-shot learning, 2022. https://arxiv.org/abs/2204.14198.", + "type": "text" + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 129, + 505, + 143 + ], + "spans": [ + { + "bbox": [ + 110, + 129, + 505, + 143 + ], + "score": 1.0, + "content": "[2] Anders Andreassen, Yasaman Bahri, Behnam Neyshabur, and Rebecca Roelofs. The evolution", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 140, + 504, + 154 + ], + "spans": [ + { + "bbox": [ + 126, + 140, + 504, + 154 + ], + "score": 1.0, + "content": "of out-of-distribution robustness throughout fine-tuning, 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 149, + 185, + 165 + ], + "spans": [ + { + "bbox": [ + 127, + 149, + 185, + 165 + ], + "score": 1.0, + "content": "2106.15831.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 168, + 506, + 182 + ], + "spans": [ + { + "bbox": [ + 110, + 168, + 506, + 182 + ], + "score": 1.0, + "content": "[3] Anonymous. Fixing model bugs with natural language patches, 2022. https://openreview.", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 181, + 259, + 192 + ], + "spans": [ + { + "bbox": [ + 127, + 181, + 259, + 192 + ], + "score": 1.0, + "content": "net/forum?id=blJrg3WvvDV.", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 199, + 506, + 213 + ], + "spans": [ + { + "bbox": [ + 110, + 199, + 506, + 213 + ], + "score": 1.0, + "content": "[4] Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 209, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 126, + 209, + 506, + 224 + ], + "score": 1.0, + "content": "Zitnick, and Devi Parikh. VQA: Visual Question Answering. In International Conference on", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 221, + 429, + 235 + ], + "spans": [ + { + "bbox": [ + 127, + 221, + 429, + 235 + ], + "score": 1.0, + "content": "Computer Vision (ICCV), 2015. https://arxiv.org/abs/1505.00468.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 110, + 239, + 506, + 253 + ], + "score": 1.0, + "content": "[5] Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101–mining discriminative", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 250, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 127, + 250, + 506, + 264 + ], + "score": 1.0, + "content": "components with random forests. In European Conference on Computer Vision (ECCV), 2014.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 126, + 261, + 459, + 274 + ], + "spans": [ + { + "bbox": [ + 126, + 261, + 459, + 274 + ], + "score": 1.0, + "content": "https://link.springer.com/chapter/10.1007/978-3-319-10599-4_29.", + "type": "text" + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 280, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 110, + 280, + 506, + 293 + ], + "score": 1.0, + "content": "[6] Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 290, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 126, + 290, + 506, + 305 + ], + "score": 1.0, + "content": "lifelong learning with a-gem. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 126, + 300, + 327, + 317 + ], + "spans": [ + { + "bbox": [ + 126, + 300, + 327, + 317 + ], + "score": 1.0, + "content": "2019. https://arxiv.org/abs/1812.00420.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 320, + 507, + 334 + ], + "spans": [ + { + "bbox": [ + 110, + 320, + 507, + 334 + ], + "score": 1.0, + "content": "[7] Gong Cheng, Junwei Han, and Xiaoqiang Lu. Remote sensing image scene classification:", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 331, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 127, + 331, + 506, + 345 + ], + "score": 1.0, + "content": "Benchmark and state of the art. Proceedings of the Institute of Electrical and Electronics Engi-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 342, + 493, + 356 + ], + "spans": [ + { + "bbox": [ + 126, + 342, + 493, + 356 + ], + "score": 1.0, + "content": "neers (IEEE), 2017. https://ieeexplore.ieee.org/abstract/document/7891544.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 110, + 360, + 508, + 376 + ], + "spans": [ + { + "bbox": [ + 110, + 360, + 508, + 376 + ], + "score": 1.0, + "content": "[8] Brian Cheung, Alexander Terekhov, Yubei Chen, Pulkit Agrawal, and Bruno Olshausen.", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 373, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 128, + 373, + 506, + 385 + ], + "score": 1.0, + "content": "Superposition of many models into one. In Advances in Neural Information Process-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 382, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 126, + 382, + 505, + 398 + ], + "score": 1.0, + "content": "ing Systems (NeurIPS), 2019. https://proceedings.neurips.cc/paper/2019/file/", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 393, + 353, + 407 + ], + "spans": [ + { + "bbox": [ + 126, + 393, + 353, + 407 + ], + "score": 1.0, + "content": "4c7a167bb329bd92580a99ce422d6fa6-Paper.pdf.", + "type": "text" + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 110, + 411, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 110, + 411, + 506, + 427 + ], + "score": 1.0, + "content": "[9] Lenaic Chizat, Edouard Oyallon, and Francis Bach. On lazy training in dif-", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 423, + 506, + 438 + ], + "spans": [ + { + "bbox": [ + 126, + 423, + 243, + 438 + ], + "score": 1.0, + "content": "ferentiable programming.", + "type": "text" + }, + { + "bbox": [ + 255, + 424, + 506, + 437 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 434, + 504, + 448 + ], + "spans": [ + { + "bbox": [ + 126, + 434, + 213, + 448 + ], + "score": 1.0, + "content": "(NeurIPS), 2019.", + "type": "text" + }, + { + "bbox": [ + 256, + 434, + 504, + 448 + ], + "score": 1.0, + "content": "https://proceedings.neurips.cc/paper/2019/file/", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 444, + 353, + 459 + ], + "spans": [ + { + "bbox": [ + 127, + 444, + 353, + 459 + ], + "score": 1.0, + "content": "ae614c557843b1df326cb29c57225459-Paper.pdf.", + "type": "text" + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 464, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 506, + 478 + ], + "score": 1.0, + "content": "[10] Leshem Choshen, Elad Venezian, Noam Slonim, and Yoav Katz. Fusing finetuned models for", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 474, + 399, + 488 + ], + "spans": [ + { + "bbox": [ + 126, + 474, + 399, + 488 + ], + "score": 1.0, + "content": "better pretraining, 2022. https://arxiv.org/abs/2204.03044.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 492, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 104, + 492, + 506, + 507 + ], + "score": 1.0, + "content": "[11] Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi.", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 127, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "Describing textures in the wild. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 126, + 514, + 504, + 529 + ], + "spans": [ + { + "bbox": [ + 126, + 514, + 504, + 529 + ], + "score": 1.0, + "content": "(CVPR), 2014. https://openaccess.thecvf.com/content_cvpr_2014/html/Cimpoi_", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 126, + 525, + 357, + 540 + ], + "spans": [ + { + "bbox": [ + 126, + 525, + 357, + 540 + ], + "score": 1.0, + "content": "Describing_Textures_in_2014_CVPR_paper.html.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 506, + 559 + ], + "score": 1.0, + "content": "[12] Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsu-", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 127, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "pervised feature learning. In International Conference on Artificial Intelligence and Statistics", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 567, + 455, + 581 + ], + "spans": [ + { + "bbox": [ + 127, + 567, + 455, + 581 + ], + "score": 1.0, + "content": "(AISTATS), 2011. https://proceedings.mlr.press/v15/coates11a.html.", + "type": "text" + } + ], + "index": 37, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 585, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 585, + 506, + 599 + ], + "score": 1.0, + "content": "[13] Nicola De Cao, Wilker Aziz, and Ivan Titov. Editing factual knowledge in language models. In", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 125, + 595, + 507, + 611 + ], + "spans": [ + { + "bbox": [ + 125, + 595, + 507, + 611 + ], + "score": 1.0, + "content": "Conference on Empirical Methods in Natural Language Processing (EMNLP), 2021. https:", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 607, + 268, + 621 + ], + "spans": [ + { + "bbox": [ + 127, + 607, + 268, + 621 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2104.08164.", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 625, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 625, + 506, + 639 + ], + "score": 1.0, + "content": "[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 126, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "hierarchical image database. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 126, + 648, + 471, + 662 + ], + "spans": [ + { + "bbox": [ + 126, + 648, + 471, + 662 + ], + "score": 1.0, + "content": "(CVPR), 2009. https://ieeexplore.ieee.org/abstract/document/5206848.", + "type": "text" + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "[15] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai,", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 675, + 507, + 693 + ], + "spans": [ + { + "bbox": [ + 126, + 675, + 507, + 693 + ], + "score": 1.0, + "content": "Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 126, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 126, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 126, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 126, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "recognition at scale. In International Conference on Learning Representations, 2021. URL", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 126, + 710, + 353, + 724 + ], + "spans": [ + { + "bbox": [ + 126, + 710, + 353, + 724 + ], + "score": 1.0, + "content": "https://openreview.net/forum?id=YicbFdNTTy.", + "type": "text" + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[16] Rahim Entezari, Hanie Sedghi, Olga Saukh, and Behnam Neyshabur. The role of permutation", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 128, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "invariance in linear mode connectivity of neural networks. In International Conference on", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 126, + 93, + 464, + 108 + ], + "spans": [ + { + "bbox": [ + 126, + 93, + 464, + 108 + ], + "score": 1.0, + "content": "Learning Representations (ICLR), 2022. https://arxiv.org/abs/2110.06296.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 113, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 505, + 126 + ], + "score": 1.0, + "content": "[17] Christian Ertler, Jerneja Mislej, Tobias Ollmann, Lorenzo Porzi, Gerhard Neuhold, and Yubin", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 125, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 125, + 505, + 137 + ], + "score": 1.0, + "content": "Kuang. The mapillary traffic sign dataset for detection and classification on a global scale. In", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 126, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 126, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "European Conference on Computer Vision (ECCV), 2020. https://arxiv.org/abs/1909.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 146, + 160, + 158 + ], + "spans": [ + { + "bbox": [ + 127, + 146, + 160, + 158 + ], + "score": 1.0, + "content": "04422.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 164, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 506, + 179 + ], + "score": 1.0, + "content": "[18] Stanislav Fort, Gintare Karolina Dziugaite, Mansheej Paul, Sepideh Kharaghani, Daniel M", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 175, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 127, + 175, + 506, + 189 + ], + "score": 1.0, + "content": "Roy, and Surya Ganguli. Deep learning versus kernel learning: an empirical study of loss", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 186, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 127, + 186, + 506, + 201 + ], + "score": 1.0, + "content": "landscape geometry and the time evolution of the neural tangent kernel. In Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 126, + 197, + 503, + 210 + ], + "spans": [ + { + "bbox": [ + 126, + 197, + 503, + 210 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2020. https://arxiv.org/abs/2010.15110.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 230 + ], + "score": 1.0, + "content": "[19] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel Roy, and Michael Carbin. Linear mode", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 227, + 506, + 242 + ], + "spans": [ + { + "bbox": [ + 126, + 227, + 506, + 242 + ], + "score": 1.0, + "content": "connectivity and the lottery ticket hypothesis. In International Conference on Machine Learning", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 237, + 453, + 252 + ], + "spans": [ + { + "bbox": [ + 126, + 237, + 453, + 252 + ], + "score": 1.0, + "content": "(ICML), 2020. https://proceedings.mlr.press/v119/frankle20a.html.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "[20] Robert M French. Catastrophic forgetting in connectionist networks. Trends in", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 268, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 127, + 268, + 505, + 282 + ], + "score": 1.0, + "content": "Cognitive Sciences, 1999. https://www.sciencedirect.com/science/article/pii/", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 128, + 280, + 222, + 292 + ], + "spans": [ + { + "bbox": [ + 128, + 280, + 222, + 292 + ], + "score": 1.0, + "content": "S1364661399012942.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 298, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 312 + ], + "score": 1.0, + "content": "[21] Peng Gao, Shijie Geng, Renrui Zhang, Teli Ma, Rongyao Fang, Yongfeng Zhang, Hongsheng", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 309, + 507, + 323 + ], + "spans": [ + { + "bbox": [ + 127, + 309, + 507, + 323 + ], + "score": 1.0, + "content": "Li, and Yu Qiao. Clip-adapter: Better vision-language models with feature adapters, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 320, + 302, + 334 + ], + "spans": [ + { + "bbox": [ + 127, + 320, + 302, + 334 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2110.04544.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "[22] Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving?", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 349, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 126, + 349, + 506, + 364 + ], + "score": 1.0, + "content": "the kitti vision benchmark suite. In Conference on Computer Vision and Pattern Recognition", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 126, + 361, + 472, + 375 + ], + "spans": [ + { + "bbox": [ + 126, + 361, + 472, + 375 + ], + "score": 1.0, + "content": "(CVPR), 2012. https://ieeexplore.ieee.org/abstract/document/6248074.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 379, + 507, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 507, + 394 + ], + "score": 1.0, + "content": "[23] Gabriel Goh, Nick Cammarata, Chelsea Voss, Shan Carter, Michael Petrov, Ludwig Schubert,", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 392, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 128, + 392, + 506, + 403 + ], + "score": 1.0, + "content": "Alec Radford, and Chris Olah. Multimodal neurons in artificial neural networks. Distill, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 402, + 358, + 415 + ], + "spans": [ + { + "bbox": [ + 126, + 402, + 358, + 415 + ], + "score": 1.0, + "content": "https://distill.pub/2021/multimodal-neurons.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 420, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 506, + 435 + ], + "score": 1.0, + "content": "[24] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 431, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 126, + 431, + 506, + 446 + ], + "score": 1.0, + "content": "recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016. https:", + "type": "text", + "cross_page": true + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 442, + 269, + 456 + ], + "spans": [ + { + "bbox": [ + 126, + 442, + 269, + 456 + ], + "score": 1.0, + "content": "//arxiv.org/abs/1512.03385.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 461, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 476 + ], + "score": 1.0, + "content": "[25] Patrick Helber, Benjamin Bischke, Andreas Dengel, and Damian Borth. Eurosat: A novel", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 128, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "dataset and deep learning benchmark for land use and land cover classification. Journal of", + "type": "text", + "cross_page": true + } + ], + "index": 30 + }, + { + "bbox": [ + 126, + 483, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 126, + 483, + 506, + 498 + ], + "score": 1.0, + "content": "Selected Topics in Applied Earth Observations and Remote Sensing, 2019. https://arxiv.", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 495, + 228, + 509 + ], + "spans": [ + { + "bbox": [ + 126, + 495, + 228, + 509 + ], + "score": 1.0, + "content": "org/abs/1709.00029.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 512, + 507, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 507, + 527 + ], + "score": 1.0, + "content": "[26] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network,", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 524, + 327, + 539 + ], + "spans": [ + { + "bbox": [ + 126, + 524, + 327, + 539 + ], + "score": 1.0, + "content": "2015. https://arxiv.org/abs/1503.02531.", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "[27] Gabriel Ilharco, Mitchell Wortsman, Ross Wightman, Cade Gordon, Nicholas Carlini, Rohan", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 554, + 507, + 568 + ], + "spans": [ + { + "bbox": [ + 127, + 554, + 507, + 568 + ], + "score": 1.0, + "content": "Taori, Achal Dave, Vaishaal Shankar, Hongseok Namkoong, John Miller, Hannaneh Hajishirzi,", + "type": "text", + "cross_page": true + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 565, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 126, + 565, + 505, + 580 + ], + "score": 1.0, + "content": "Ali Farhadi, and Ludwig Schmidt. Openclip, 2021. https://github.com/mlfoundations/", + "type": "text", + "cross_page": true + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 575, + 181, + 591 + ], + "spans": [ + { + "bbox": [ + 126, + 575, + 181, + 591 + ], + "score": 1.0, + "content": "open_clip.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 595, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 506, + 609 + ], + "score": 1.0, + "content": "[28] Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 604, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 126, + 604, + 507, + 622 + ], + "score": 1.0, + "content": "Wilson. Averaging weights leads to wider optima and better generalization. In Conference on", + "type": "text", + "cross_page": true + } + ], + "index": 40 + }, + { + "bbox": [ + 128, + 618, + 500, + 630 + ], + "spans": [ + { + "bbox": [ + 128, + 618, + 500, + 630 + ], + "score": 1.0, + "content": "Uncertainty in Artificial Intelligence (UAI), 2018. https://arxiv.org/abs/1803.05407.", + "type": "text", + "cross_page": true + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 637, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 506, + 649 + ], + "score": 1.0, + "content": "[29] Joel Jang, Seonghyeon Ye, Changho Lee, Sohee Yang, Joongbo Shin, Janghoon Han,", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 127, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 127, + 647, + 506, + 661 + ], + "score": 1.0, + "content": "Gyeonghun Kim, and Minjoon Seo. Temporalwiki: A lifelong benchmark for training and", + "type": "text", + "cross_page": true + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 658, + 499, + 673 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 499, + 673 + ], + "score": 1.0, + "content": "evaluating ever-evolving language models, 2022. https://arxiv.org/abs/2204.14211.", + "type": "text", + "cross_page": true + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 678, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 107, + 678, + 506, + 690 + ], + "score": 1.0, + "content": "[30] Joel Jang, Seonghyeon Ye, Sohee Yang, Joongbo Shin, Janghoon Han, Gyeonghun Kim,", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 126, + 686, + 507, + 704 + ], + "spans": [ + { + "bbox": [ + 126, + 686, + 507, + 704 + ], + "score": 1.0, + "content": "Stanley Jungkyu Choi, and Minjoon Seo. Towards continual knowledge learning of language", + "type": "text", + "cross_page": true + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 699, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 507, + 713 + ], + "score": 1.0, + "content": "models. In International Conference on Learning Representations (ICLR), 2022. https:", + "type": "text", + "cross_page": true + } + ], + "index": 47 + }, + { + "bbox": [ + 128, + 711, + 268, + 723 + ], + "spans": [ + { + "bbox": [ + 128, + 711, + 268, + 723 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2110.03215.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_end_line": true + } + ], + "index": 24, + "bbox_fs": [ + 104, + 68, + 508, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 40, + 507, + 734 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[16] Rahim Entezari, Hanie Sedghi, Olga Saukh, and Behnam Neyshabur. The role of permutation", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 128, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 128, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "invariance in linear mode connectivity of neural networks. In International Conference on", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 126, + 93, + 464, + 108 + ], + "spans": [ + { + "bbox": [ + 126, + 93, + 464, + 108 + ], + "score": 1.0, + "content": "Learning Representations (ICLR), 2022. https://arxiv.org/abs/2110.06296.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 113, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 505, + 126 + ], + "score": 1.0, + "content": "[17] Christian Ertler, Jerneja Mislej, Tobias Ollmann, Lorenzo Porzi, Gerhard Neuhold, and Yubin", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 125, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 125, + 505, + 137 + ], + "score": 1.0, + "content": "Kuang. The mapillary traffic sign dataset for detection and classification on a global scale. In", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 126, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 126, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "European Conference on Computer Vision (ECCV), 2020. https://arxiv.org/abs/1909.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 146, + 160, + 158 + ], + "spans": [ + { + "bbox": [ + 127, + 146, + 160, + 158 + ], + "score": 1.0, + "content": "04422.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 164, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 506, + 179 + ], + "score": 1.0, + "content": "[18] Stanislav Fort, Gintare Karolina Dziugaite, Mansheej Paul, Sepideh Kharaghani, Daniel M", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 175, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 127, + 175, + 506, + 189 + ], + "score": 1.0, + "content": "Roy, and Surya Ganguli. Deep learning versus kernel learning: an empirical study of loss", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 186, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 127, + 186, + 506, + 201 + ], + "score": 1.0, + "content": "landscape geometry and the time evolution of the neural tangent kernel. In Advances in Neural", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 126, + 197, + 503, + 210 + ], + "spans": [ + { + "bbox": [ + 126, + 197, + 503, + 210 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2020. https://arxiv.org/abs/2010.15110.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 216, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 505, + 230 + ], + "score": 1.0, + "content": "[19] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel Roy, and Michael Carbin. Linear mode", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 126, + 227, + 506, + 242 + ], + "spans": [ + { + "bbox": [ + 126, + 227, + 506, + 242 + ], + "score": 1.0, + "content": "connectivity and the lottery ticket hypothesis. In International Conference on Machine Learning", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 237, + 453, + 252 + ], + "spans": [ + { + "bbox": [ + 126, + 237, + 453, + 252 + ], + "score": 1.0, + "content": "(ICML), 2020. https://proceedings.mlr.press/v119/frankle20a.html.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 505, + 271 + ], + "score": 1.0, + "content": "[20] Robert M French. Catastrophic forgetting in connectionist networks. Trends in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 127, + 268, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 127, + 268, + 505, + 282 + ], + "score": 1.0, + "content": "Cognitive Sciences, 1999. https://www.sciencedirect.com/science/article/pii/", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 128, + 280, + 222, + 292 + ], + "spans": [ + { + "bbox": [ + 128, + 280, + 222, + 292 + ], + "score": 1.0, + "content": "S1364661399012942.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 298, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 506, + 312 + ], + "score": 1.0, + "content": "[21] Peng Gao, Shijie Geng, Renrui Zhang, Teli Ma, Rongyao Fang, Yongfeng Zhang, Hongsheng", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 309, + 507, + 323 + ], + "spans": [ + { + "bbox": [ + 127, + 309, + 507, + 323 + ], + "score": 1.0, + "content": "Li, and Yu Qiao. Clip-adapter: Better vision-language models with feature adapters, 2021.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 320, + 302, + 334 + ], + "spans": [ + { + "bbox": [ + 127, + 320, + 302, + 334 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2110.04544.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 339, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 506, + 353 + ], + "score": 1.0, + "content": "[22] Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving?", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 126, + 349, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 126, + 349, + 506, + 364 + ], + "score": 1.0, + "content": "the kitti vision benchmark suite. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 126, + 361, + 472, + 375 + ], + "spans": [ + { + "bbox": [ + 126, + 361, + 472, + 375 + ], + "score": 1.0, + "content": "(CVPR), 2012. https://ieeexplore.ieee.org/abstract/document/6248074.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 379, + 507, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 507, + 394 + ], + "score": 1.0, + "content": "[23] Gabriel Goh, Nick Cammarata, Chelsea Voss, Shan Carter, Michael Petrov, Ludwig Schubert,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 128, + 392, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 128, + 392, + 506, + 403 + ], + "score": 1.0, + "content": "Alec Radford, and Chris Olah. Multimodal neurons in artificial neural networks. Distill, 2021.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 126, + 402, + 358, + 415 + ], + "spans": [ + { + "bbox": [ + 126, + 402, + 358, + 415 + ], + "score": 1.0, + "content": "https://distill.pub/2021/multimodal-neurons.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 420, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 506, + 435 + ], + "score": 1.0, + "content": "[24] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 431, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 126, + 431, + 506, + 446 + ], + "score": 1.0, + "content": "recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016. https:", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 442, + 269, + 456 + ], + "spans": [ + { + "bbox": [ + 126, + 442, + 269, + 456 + ], + "score": 1.0, + "content": "//arxiv.org/abs/1512.03385.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 461, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 476 + ], + "score": 1.0, + "content": "[25] Patrick Helber, Benjamin Bischke, Andreas Dengel, and Damian Borth. Eurosat: A novel", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 128, + 474, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 128, + 474, + 505, + 486 + ], + "score": 1.0, + "content": "dataset and deep learning benchmark for land use and land cover classification. Journal of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 126, + 483, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 126, + 483, + 506, + 498 + ], + "score": 1.0, + "content": "Selected Topics in Applied Earth Observations and Remote Sensing, 2019. https://arxiv.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 126, + 495, + 228, + 509 + ], + "spans": [ + { + "bbox": [ + 126, + 495, + 228, + 509 + ], + "score": 1.0, + "content": "org/abs/1709.00029.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 512, + 507, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 507, + 527 + ], + "score": 1.0, + "content": "[26] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 126, + 524, + 327, + 539 + ], + "spans": [ + { + "bbox": [ + 126, + 524, + 327, + 539 + ], + "score": 1.0, + "content": "2015. https://arxiv.org/abs/1503.02531.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "[27] Gabriel Ilharco, Mitchell Wortsman, Ross Wightman, Cade Gordon, Nicholas Carlini, Rohan", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 554, + 507, + 568 + ], + "spans": [ + { + "bbox": [ + 127, + 554, + 507, + 568 + ], + "score": 1.0, + "content": "Taori, Achal Dave, Vaishaal Shankar, Hongseok Namkoong, John Miller, Hannaneh Hajishirzi,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 565, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 126, + 565, + 505, + 580 + ], + "score": 1.0, + "content": "Ali Farhadi, and Ludwig Schmidt. Openclip, 2021. https://github.com/mlfoundations/", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 575, + 181, + 591 + ], + "spans": [ + { + "bbox": [ + 126, + 575, + 181, + 591 + ], + "score": 1.0, + "content": "open_clip.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 595, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 595, + 506, + 609 + ], + "score": 1.0, + "content": "[28] Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 126, + 604, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 126, + 604, + 507, + 622 + ], + "score": 1.0, + "content": "Wilson. Averaging weights leads to wider optima and better generalization. In Conference on", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 128, + 618, + 500, + 630 + ], + "spans": [ + { + "bbox": [ + 128, + 618, + 500, + 630 + ], + "score": 1.0, + "content": "Uncertainty in Artificial Intelligence (UAI), 2018. https://arxiv.org/abs/1803.05407.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 637, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 506, + 649 + ], + "score": 1.0, + "content": "[29] Joel Jang, Seonghyeon Ye, Changho Lee, Sohee Yang, Joongbo Shin, Janghoon Han,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 647, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 127, + 647, + 506, + 661 + ], + "score": 1.0, + "content": "Gyeonghun Kim, and Minjoon Seo. Temporalwiki: A lifelong benchmark for training and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 658, + 499, + 673 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 499, + 673 + ], + "score": 1.0, + "content": "evaluating ever-evolving language models, 2022. https://arxiv.org/abs/2204.14211.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 678, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 107, + 678, + 506, + 690 + ], + "score": 1.0, + "content": "[30] Joel Jang, Seonghyeon Ye, Sohee Yang, Joongbo Shin, Janghoon Han, Gyeonghun Kim,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 126, + 686, + 507, + 704 + ], + "spans": [ + { + "bbox": [ + 126, + 686, + 507, + 704 + ], + "score": 1.0, + "content": "Stanley Jungkyu Choi, and Minjoon Seo. Towards continual knowledge learning of language", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 699, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 507, + 713 + ], + "score": 1.0, + "content": "models. In International Conference on Learning Representations (ICLR), 2022. https:", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 128, + 711, + 268, + 723 + ], + "spans": [ + { + "bbox": [ + 128, + 711, + 268, + 723 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2110.03215.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 24 + } + ], + "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": [ + 105, + 40, + 507, + 734 + ], + "lines": [], + "index": 24, + "bbox_fs": [ + 104, + 72, + 507, + 723 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 506, + 117 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "[31] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V Le, Yunhsuan", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "Sung, Zhen Li, and Tom Duerig. Scaling up visual and vision-language representation learning", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 94, + 507, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 94, + 507, + 107 + ], + "score": 1.0, + "content": "with noisy text supervision. In International Conference on Machine Learning (ICML), 2021.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 105, + 300, + 117 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 300, + 117 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2102.05918.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 107, + 125, + 506, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 125, + 507, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 507, + 137 + ], + "score": 1.0, + "content": "[32] Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 127, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 128, + 147, + 507, + 159 + ], + "spans": [ + { + "bbox": [ + 128, + 147, + 507, + 159 + ], + "score": 1.0, + "content": "visual reasoning. Conference on Computer Vision and Pattern Recognition (CVPR), 2017.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 158, + 300, + 170 + ], + "spans": [ + { + "bbox": [ + 127, + 158, + 300, + 170 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1612.06890.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 506, + 222 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 507, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 507, + 191 + ], + "score": 1.0, + "content": "[33] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 189, + 507, + 201 + ], + "spans": [ + { + "bbox": [ + 127, + 189, + 507, + 201 + ], + "score": 1.0, + "content": "Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 127, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 210, + 409, + 223 + ], + "spans": [ + { + "bbox": [ + 127, + 210, + 409, + 223 + ], + "score": 1.0, + "content": "of Sciences (PNAS), 2017. https://arxiv.org/abs/1612.00796.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 230, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 506, + 243 + ], + "score": 1.0, + "content": "[34] Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 241, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 127, + 241, + 506, + 254 + ], + "score": 1.0, + "content": "network representations revisited. In International Conference on Machine Learning (ICML),", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 251, + 326, + 265 + ], + "spans": [ + { + "bbox": [ + 127, + 251, + 326, + 265 + ], + "score": 1.0, + "content": "2019. https://arxiv.org/abs/1905.00414.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 272, + 506, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 271, + 507, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 507, + 284 + ], + "score": 1.0, + "content": "[35] Jonathan Krause, Michael Stark, Jia Deng, and Li Fei-Fei. 3d object representations for fine-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 282, + 507, + 295 + ], + "spans": [ + { + "bbox": [ + 126, + 282, + 507, + 295 + ], + "score": 1.0, + "content": "grained categorization. In International Conference on Computer Vision Workshops (ICML),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 127, + 293, + 155, + 306 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + }, + { + "bbox": [ + 165, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "https://www.cv-foundation.org/openaccess/content_iccv_workshops_", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 304, + 484, + 317 + ], + "spans": [ + { + "bbox": [ + 127, + 304, + 484, + 317 + ], + "score": 1.0, + "content": "2013/W19/html/Krause_3D_Object_Representations_2013_ICCV_paper.html.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 106, + 325, + 504, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 323, + 507, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 507, + 338 + ], + "score": 1.0, + "content": "[36] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 334, + 484, + 348 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 484, + 348 + ], + "score": 1.0, + "content": "2009. https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 355, + 506, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 354, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 506, + 369 + ], + "score": 1.0, + "content": "[37] Ananya Kumar, Aditi Raghunathan, Robbie Jones, Tengyu Ma, and Percy Liang. Fine-tuning", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 367, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 127, + 367, + 506, + 379 + ], + "score": 1.0, + "content": "can distort pretrained features and underperform out-of-distribution. In International Confer-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 377, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 126, + 377, + 505, + 389 + ], + "score": 1.0, + "content": "ence on Learning Representations (ICLR), 2022. https://openreview.net/forum?id=", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 389, + 190, + 399 + ], + "spans": [ + { + "bbox": [ + 127, + 389, + 190, + 399 + ], + "score": 1.0, + "content": "UYneFzXSJWh.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 407, + 506, + 452 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "[38] Angeliki Lazaridou, Adhi Kuncoro, Elena Gribovskaya, Devang Agrawal, Adam Liska, Tayfun", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 419, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 127, + 419, + 506, + 431 + ], + "score": 1.0, + "content": "Terzi, Mai Gimenez, Cyprien de Masson d’Autume, Tomas Kocisky, Sebastian Ruder, et al.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 429, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 127, + 429, + 506, + 443 + ], + "score": 1.0, + "content": "Mind the gap: Assessing temporal generalization in neural language models. Advances in Neural", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 441, + 503, + 453 + ], + "spans": [ + { + "bbox": [ + 126, + 441, + 503, + 453 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2021. https://arxiv.org/abs/2102.01951.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 105, + 460, + 505, + 483 + ], + "lines": [ + { + "bbox": [ + 105, + 458, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 473 + ], + "score": 1.0, + "content": "[39] Yann LeCun. The mnist database of handwritten digits, 1998. http://yann.lecun.com/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 127, + 471, + 190, + 483 + ], + "spans": [ + { + "bbox": [ + 127, + 471, + 190, + 483 + ], + "score": 1.0, + "content": "exdb/mnist/.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 504, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "score": 1.0, + "content": "[40] Sang-Woo Lee, Jin-Hwa Kim, Jaehyun Jun, Jung-Woo Ha, and Byoung-Tak Zhang. Overcoming", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 127, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "catastrophic forgetting by incremental moment matching. In Advances in Neural Information", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 513, + 452, + 525 + ], + "spans": [ + { + "bbox": [ + 127, + 513, + 452, + 525 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017. https://arxiv.org/abs/1703.08475.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 105, + 533, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "[41] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 126, + 543, + 468, + 556 + ], + "spans": [ + { + "bbox": [ + 126, + 543, + 468, + 556 + ], + "score": 1.0, + "content": "Analysis and Machine Intelligence, 2017. https://arxiv.org/abs/1606.09282.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 506, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 507, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 507, + 578 + ], + "score": 1.0, + "content": "[42] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "spans": [ + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "score": 1.0, + "content": "In Advances in Neural Information Processing Systems (NeurIPS), 2017. https://arxiv.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 586, + 227, + 597 + ], + "spans": [ + { + "bbox": [ + 127, + 586, + 227, + 597 + ], + "score": 1.0, + "content": "org/abs/1706.08840.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 106, + 605, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "[43] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 127, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2019. URL https://openreview.net/forum?", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 626, + 200, + 640 + ], + "spans": [ + { + "bbox": [ + 127, + 626, + 200, + 640 + ], + "score": 1.0, + "content": "id=Bkg6RiCqY7.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 106, + 647, + 505, + 680 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "[44] Ekdeep Singh Lubana, Puja Trivedi, Danai Koutra, and Robert P. Dick. How do quadratic", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 658, + 507, + 671 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 507, + 671 + ], + "score": 1.0, + "content": "regularizers prevent catastrophic forgetting: The role of interpolation, 2021. https://arxiv.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 669, + 227, + 680 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 227, + 680 + ], + "score": 1.0, + "content": "org/abs/2102.02805.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "score": 1.0, + "content": "[45] Kelvin Luu, Daniel Khashabi, Suchin Gururangan, Karishma Mandyam, and Noah A Smith.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 699, + 507, + 712 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 507, + 712 + ], + "score": 1.0, + "content": "Time waits for no one! analysis and challenges of temporal misalignment, 2021. https:", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 128, + 710, + 268, + 722 + ], + "spans": [ + { + "bbox": [ + 128, + 710, + 268, + 722 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2111.07408.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46 + } + ], + "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": "text", + "bbox": [ + 107, + 72, + 506, + 117 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "[31] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V Le, Yunhsuan", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 127, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "Sung, Zhen Li, and Tom Duerig. Scaling up visual and vision-language representation learning", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 94, + 507, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 94, + 507, + 107 + ], + "score": 1.0, + "content": "with noisy text supervision. In International Conference on Machine Learning (ICML), 2021.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 127, + 105, + 300, + 117 + ], + "spans": [ + { + "bbox": [ + 127, + 105, + 300, + 117 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2102.05918.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5, + "bbox_fs": [ + 106, + 72, + 507, + 117 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 125, + 506, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 125, + 507, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 507, + 137 + ], + "score": 1.0, + "content": "[32] Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 127, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 128, + 147, + 507, + 159 + ], + "spans": [ + { + "bbox": [ + 128, + 147, + 507, + 159 + ], + "score": 1.0, + "content": "visual reasoning. Conference on Computer Vision and Pattern Recognition (CVPR), 2017.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 158, + 300, + 170 + ], + "spans": [ + { + "bbox": [ + 127, + 158, + 300, + 170 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1612.06890.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 125, + 507, + 170 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 506, + 222 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 507, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 507, + 191 + ], + "score": 1.0, + "content": "[33] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 189, + 507, + 201 + ], + "spans": [ + { + "bbox": [ + 127, + 189, + 507, + 201 + ], + "score": 1.0, + "content": "Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 127, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 210, + 409, + 223 + ], + "spans": [ + { + "bbox": [ + 127, + 210, + 409, + 223 + ], + "score": 1.0, + "content": "of Sciences (PNAS), 2017. https://arxiv.org/abs/1612.00796.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5, + "bbox_fs": [ + 106, + 177, + 507, + 223 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 230, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 506, + 243 + ], + "score": 1.0, + "content": "[34] Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 127, + 241, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 127, + 241, + 506, + 254 + ], + "score": 1.0, + "content": "network representations revisited. In International Conference on Machine Learning (ICML),", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 251, + 326, + 265 + ], + "spans": [ + { + "bbox": [ + 127, + 251, + 326, + 265 + ], + "score": 1.0, + "content": "2019. https://arxiv.org/abs/1905.00414.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 229, + 506, + 265 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 272, + 506, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 271, + 507, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 507, + 284 + ], + "score": 1.0, + "content": "[35] Jonathan Krause, Michael Stark, Jia Deng, and Li Fei-Fei. 3d object representations for fine-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 126, + 282, + 507, + 295 + ], + "spans": [ + { + "bbox": [ + 126, + 282, + 507, + 295 + ], + "score": 1.0, + "content": "grained categorization. In International Conference on Computer Vision Workshops (ICML),", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 293, + 506, + 307 + ], + "spans": [ + { + "bbox": [ + 127, + 293, + 155, + 306 + ], + "score": 1.0, + "content": "2013.", + "type": "text" + }, + { + "bbox": [ + 165, + 293, + 506, + 307 + ], + "score": 1.0, + "content": "https://www.cv-foundation.org/openaccess/content_iccv_workshops_", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 127, + 304, + 484, + 317 + ], + "spans": [ + { + "bbox": [ + 127, + 304, + 484, + 317 + ], + "score": 1.0, + "content": "2013/W19/html/Krause_3D_Object_Representations_2013_ICCV_paper.html.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 271, + 507, + 317 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 325, + 504, + 348 + ], + "lines": [ + { + "bbox": [ + 105, + 323, + 507, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 323, + 507, + 338 + ], + "score": 1.0, + "content": "[36] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 334, + 484, + 348 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 484, + 348 + ], + "score": 1.0, + "content": "2009. https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 323, + 507, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 355, + 506, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 354, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 506, + 369 + ], + "score": 1.0, + "content": "[37] Ananya Kumar, Aditi Raghunathan, Robbie Jones, Tengyu Ma, and Percy Liang. Fine-tuning", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 367, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 127, + 367, + 506, + 379 + ], + "score": 1.0, + "content": "can distort pretrained features and underperform out-of-distribution. In International Confer-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 377, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 126, + 377, + 505, + 389 + ], + "score": 1.0, + "content": "ence on Learning Representations (ICLR), 2022. https://openreview.net/forum?id=", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 389, + 190, + 399 + ], + "spans": [ + { + "bbox": [ + 127, + 389, + 190, + 399 + ], + "score": 1.0, + "content": "UYneFzXSJWh.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 354, + 506, + 399 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 407, + 506, + 452 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "[38] Angeliki Lazaridou, Adhi Kuncoro, Elena Gribovskaya, Devang Agrawal, Adam Liska, Tayfun", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 127, + 419, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 127, + 419, + 506, + 431 + ], + "score": 1.0, + "content": "Terzi, Mai Gimenez, Cyprien de Masson d’Autume, Tomas Kocisky, Sebastian Ruder, et al.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 429, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 127, + 429, + 506, + 443 + ], + "score": 1.0, + "content": "Mind the gap: Assessing temporal generalization in neural language models. Advances in Neural", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 126, + 441, + 503, + 453 + ], + "spans": [ + { + "bbox": [ + 126, + 441, + 503, + 453 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2021. https://arxiv.org/abs/2102.01951.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 106, + 407, + 506, + 453 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 460, + 505, + 483 + ], + "lines": [ + { + "bbox": [ + 105, + 458, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 458, + 505, + 473 + ], + "score": 1.0, + "content": "[39] Yann LeCun. The mnist database of handwritten digits, 1998. http://yann.lecun.com/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 127, + 471, + 190, + 483 + ], + "spans": [ + { + "bbox": [ + 127, + 471, + 190, + 483 + ], + "score": 1.0, + "content": "exdb/mnist/.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 458, + 505, + 483 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 504, + 525 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 505, + 505 + ], + "score": 1.0, + "content": "[40] Sang-Woo Lee, Jin-Hwa Kim, Jaehyun Jun, Jung-Woo Ha, and Byoung-Tak Zhang. Overcoming", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 127, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "catastrophic forgetting by incremental moment matching. In Advances in Neural Information", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 513, + 452, + 525 + ], + "spans": [ + { + "bbox": [ + 127, + 513, + 452, + 525 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017. https://arxiv.org/abs/1703.08475.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 491, + 505, + 525 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 533, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 506, + 545 + ], + "score": 1.0, + "content": "[41] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 126, + 543, + 468, + 556 + ], + "spans": [ + { + "bbox": [ + 126, + 543, + 468, + 556 + ], + "score": 1.0, + "content": "Analysis and Machine Intelligence, 2017. https://arxiv.org/abs/1606.09282.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 106, + 532, + 506, + 556 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 506, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 562, + 507, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 562, + 507, + 578 + ], + "score": 1.0, + "content": "[42] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "spans": [ + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "score": 1.0, + "content": "In Advances in Neural Information Processing Systems (NeurIPS), 2017. https://arxiv.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 586, + 227, + 597 + ], + "spans": [ + { + "bbox": [ + 127, + 586, + 227, + 597 + ], + "score": 1.0, + "content": "org/abs/1706.08840.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 562, + 507, + 597 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 605, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "[43] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 127, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2019. URL https://openreview.net/forum?", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 626, + 200, + 640 + ], + "spans": [ + { + "bbox": [ + 127, + 626, + 200, + 640 + ], + "score": 1.0, + "content": "id=Bkg6RiCqY7.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 605, + 506, + 640 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 647, + 505, + 680 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 506, + 660 + ], + "score": 1.0, + "content": "[44] Ekdeep Singh Lubana, Puja Trivedi, Danai Koutra, and Robert P. Dick. How do quadratic", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 658, + 507, + 671 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 507, + 671 + ], + "score": 1.0, + "content": "regularizers prevent catastrophic forgetting: The role of interpolation, 2021. https://arxiv.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 669, + 227, + 680 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 227, + 680 + ], + "score": 1.0, + "content": "org/abs/2102.02805.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 646, + 507, + 680 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 701 + ], + "score": 1.0, + "content": "[45] Kelvin Luu, Daniel Khashabi, Suchin Gururangan, Karishma Mandyam, and Noah A Smith.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 699, + 507, + 712 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 507, + 712 + ], + "score": 1.0, + "content": "Time waits for no one! analysis and challenges of temporal misalignment, 2021. https:", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 128, + 710, + 268, + 722 + ], + "spans": [ + { + "bbox": [ + 128, + 710, + 268, + 722 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2111.07408.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 687, + 507, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 72, + 504, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "[46] Arun Mallya, Dillon Davis, and Svetlana Lazebnik. Piggyback: Adapting a single network", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "to multiple tasks by learning to mask weights. In European Conference on Computer Vision", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 363, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 363, + 107 + ], + "score": 1.0, + "content": "(ECCV), 2018. https://arxiv.org/abs/1801.06519.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 103, + 114, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 113, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 506, + 126 + ], + "score": 1.0, + "content": "[47] Michael Matena and Colin Raffel. Merging models with fisher-weighted averaging, 2021.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 127, + 124, + 300, + 137 + ], + "spans": [ + { + "bbox": [ + 127, + 124, + 300, + 137 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2111.09832.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 179 + ], + "lines": [ + { + "bbox": [ + 105, + 144, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 507, + 157 + ], + "score": 1.0, + "content": "[48] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks:", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 155, + 507, + 169 + ], + "spans": [ + { + "bbox": [ + 127, + 155, + 507, + 169 + ], + "score": 1.0, + "content": "The sequential learning problem. In Psychology of Learning and Motivation. Elsevier, 1989.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 127, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "https://www.sciencedirect.com/science/article/abs/pii/S0079742108605368.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 186, + 505, + 219 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "[49] Sanket Vaibhav Mehta, Darshan Patil, Sarath Chandar, and Emma Strubell. An empirical", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 127, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "investigation of the role of pre-training in lifelong learning, 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 207, + 186, + 221 + ], + "spans": [ + { + "bbox": [ + 127, + 207, + 186, + 221 + ], + "score": 1.0, + "content": "2112.09153.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 506, + 273 + ], + "lines": [ + { + "bbox": [ + 106, + 228, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 506, + 241 + ], + "score": 1.0, + "content": "[50] Seyed Iman Mirzadeh, Mehrdad Farajtabar, Dilan Gorur, Razvan Pascanu, and Hassan", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 127, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "Ghasemzadeh. Linear mode connectivity in multitask and continual learning. In Interna-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 249, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 126, + 249, + 505, + 263 + ], + "score": 1.0, + "content": "tional Conference on Learning Representations (ICLR), 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 261, + 185, + 272 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 185, + 272 + ], + "score": 1.0, + "content": "2010.04495.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 281, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 506, + 294 + ], + "score": 1.0, + "content": "[51] Eric Mitchell, Charles Lin, Antoine Bosselut, Chelsea Finn, and Christopher D Manning. Fast", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 292, + 507, + 304 + ], + "spans": [ + { + "bbox": [ + 127, + 292, + 507, + 304 + ], + "score": 1.0, + "content": "model editing at scale. In International Conference on Learning Representations (ICLR), 2021.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 302, + 300, + 315 + ], + "spans": [ + { + "bbox": [ + 127, + 302, + 300, + 315 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2110.11309.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 322, + 504, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "[52] Vaishnavh Nagarajan and J. Zico Kolter. Uniform convergence may be unable to explain", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 126, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "generalization in deep learning. In NeurIPS, 2019. https://proceedings.neurips.cc/", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 344, + 438, + 357 + ], + "spans": [ + { + "bbox": [ + 126, + 344, + 438, + 357 + ], + "score": 1.0, + "content": "paper/2019/file/05e97c207235d63ceb1db43c60db7bbb-Paper.pdf.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 364, + 507, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 507, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 507, + 378 + ], + "score": 1.0, + "content": "[53] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 375, + 507, + 388 + ], + "spans": [ + { + "bbox": [ + 127, + 375, + 507, + 388 + ], + "score": 1.0, + "content": "Reading digits in natural images with unsupervised feature learning. In Advances in Neural In-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 385, + 508, + 399 + ], + "spans": [ + { + "bbox": [ + 126, + 385, + 508, + 399 + ], + "score": 1.0, + "content": "formation Processing Systems (NeurIPS) Workshops, 2011. https://storage.googleapis.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 397, + 402, + 410 + ], + "spans": [ + { + "bbox": [ + 127, + 397, + 402, + 410 + ], + "score": 1.0, + "content": "com/pub-tools-public-publication-data/pdf/37648.pdf.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 416, + 504, + 451 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "[54] Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 427, + 507, + 440 + ], + "spans": [ + { + "bbox": [ + 126, + 427, + 507, + 440 + ], + "score": 1.0, + "content": "learning? In Advances in Neural Information Processing Systems (NeurIPS), 2020. https:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 439, + 268, + 451 + ], + "spans": [ + { + "bbox": [ + 127, + 439, + 268, + 451 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2008.11687.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 458, + 504, + 503 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 472 + ], + "score": 1.0, + "content": "[55] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 127, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 127, + 480, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 127, + 480, + 505, + 494 + ], + "score": 1.0, + "content": "style, high-performance deep learning library. Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 491, + 406, + 504 + ], + "spans": [ + { + "bbox": [ + 127, + 491, + 406, + 504 + ], + "score": 1.0, + "content": "Systems (NeurIPS), 2019. https://arxiv.org/abs/1912.01703.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 505, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 507, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 507, + 525 + ], + "score": 1.0, + "content": "[56] Hieu Pham, Zihang Dai, Golnaz Ghiasi, Hanxiao Liu, Adams Wei Yu, Minh-Thang Luong,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 522, + 507, + 534 + ], + "spans": [ + { + "bbox": [ + 127, + 522, + 507, + 534 + ], + "score": 1.0, + "content": "Mingxing Tan, and Quoc V Le. Combined scaling for zero-shot transfer learning, 2021.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 532, + 300, + 545 + ], + "spans": [ + { + "bbox": [ + 127, + 532, + 300, + 545 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2111.10050.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 506, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 507, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 507, + 566 + ], + "score": 1.0, + "content": "[57] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agar-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 127, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "wal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "spans": [ + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "score": 1.0, + "content": "Sutskever. Learning transferable visual models from natural language supervision. In Inter-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 585, + 507, + 598 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 507, + 598 + ], + "score": 1.0, + "content": "national Conference on Machine Learning (ICML), 2021. https://arxiv.org/abs/2103.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 595, + 159, + 609 + ], + "spans": [ + { + "bbox": [ + 127, + 595, + 159, + 609 + ], + "score": 1.0, + "content": "00020.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 105, + 616, + 506, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 614, + 507, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 197, + 628 + ], + "score": 1.0, + "content": "[58] Colin Raffel.", + "type": "text" + }, + { + "bbox": [ + 233, + 614, + 507, + 630 + ], + "score": 1.0, + "content": "A call to build models like we build open-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 625, + 504, + 640 + ], + "spans": [ + { + "bbox": [ + 126, + 628, + 159, + 639 + ], + "score": 1.0, + "content": "source", + "type": "text" + }, + { + "bbox": [ + 179, + 625, + 222, + 640 + ], + "score": 1.0, + "content": "software,", + "type": "text" + }, + { + "bbox": [ + 248, + 625, + 276, + 639 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + }, + { + "bbox": [ + 351, + 626, + 504, + 640 + ], + "score": 1.0, + "content": "https://colinraffel.com/blog/", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 637, + 462, + 650 + ], + "spans": [ + { + "bbox": [ + 126, + 637, + 462, + 650 + ], + "score": 1.0, + "content": "a-call-to-build-models-like-we-build-open-source-software.html.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 658, + 504, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "[59] Vinay Venkatesh Ramasesh, Aitor Lewkowycz, and Ethan Dyer. Effect of scale on catastrophic", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 668, + 506, + 682 + ], + "spans": [ + { + "bbox": [ + 127, + 668, + 506, + 682 + ], + "score": 1.0, + "content": "forgetting in neural networks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 679, + 383, + 693 + ], + "spans": [ + { + "bbox": [ + 127, + 679, + 383, + 693 + ], + "score": 1.0, + "content": "2021. https://openreview.net/forum?id=GhVS8_yPeEa.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 106, + 700, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 504, + 712 + ], + "score": 1.0, + "content": "[60] J. Rapin and O. Teytaud. Nevergrad - A gradient-free optimization platform. https://GitHub.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 710, + 315, + 722 + ], + "spans": [ + { + "bbox": [ + 127, + 710, + 315, + 722 + ], + "score": 1.0, + "content": "com/FacebookResearch/Nevergrad, 2018.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.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": "text", + "bbox": [ + 106, + 72, + 504, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 86 + ], + "score": 1.0, + "content": "[46] Arun Mallya, Dillon Davis, and Svetlana Lazebnik. Piggyback: Adapting a single network", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "to multiple tasks by learning to mask weights. In European Conference on Computer Vision", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 127, + 95, + 363, + 107 + ], + "spans": [ + { + "bbox": [ + 127, + 95, + 363, + 107 + ], + "score": 1.0, + "content": "(ECCV), 2018. https://arxiv.org/abs/1801.06519.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 72, + 506, + 107 + ] + }, + { + "type": "text", + "bbox": [ + 103, + 114, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 106, + 113, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 506, + 126 + ], + "score": 1.0, + "content": "[47] Michael Matena and Colin Raffel. Merging models with fisher-weighted averaging, 2021.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 127, + 124, + 300, + 137 + ], + "spans": [ + { + "bbox": [ + 127, + 124, + 300, + 137 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2111.09832.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 106, + 113, + 506, + 137 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 179 + ], + "lines": [ + { + "bbox": [ + 105, + 144, + 507, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 507, + 157 + ], + "score": 1.0, + "content": "[48] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks:", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 155, + 507, + 169 + ], + "spans": [ + { + "bbox": [ + 127, + 155, + 507, + 169 + ], + "score": 1.0, + "content": "The sequential learning problem. In Psychology of Learning and Motivation. Elsevier, 1989.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 166, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 127, + 166, + 505, + 180 + ], + "score": 1.0, + "content": "https://www.sciencedirect.com/science/article/abs/pii/S0079742108605368.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 144, + 507, + 180 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 186, + 505, + 219 + ], + "lines": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 505, + 199 + ], + "score": 1.0, + "content": "[49] Sanket Vaibhav Mehta, Darshan Patil, Sarath Chandar, and Emma Strubell. An empirical", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 127, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 127, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "investigation of the role of pre-training in lifelong learning, 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 207, + 186, + 221 + ], + "spans": [ + { + "bbox": [ + 127, + 207, + 186, + 221 + ], + "score": 1.0, + "content": "2112.09153.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 186, + 505, + 221 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 227, + 506, + 273 + ], + "lines": [ + { + "bbox": [ + 106, + 228, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 506, + 241 + ], + "score": 1.0, + "content": "[50] Seyed Iman Mirzadeh, Mehrdad Farajtabar, Dilan Gorur, Razvan Pascanu, and Hassan", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 127, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 127, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "Ghasemzadeh. Linear mode connectivity in multitask and continual learning. In Interna-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 126, + 249, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 126, + 249, + 505, + 263 + ], + "score": 1.0, + "content": "tional Conference on Learning Representations (ICLR), 2021. https://arxiv.org/abs/", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 261, + 185, + 272 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 185, + 272 + ], + "score": 1.0, + "content": "2010.04495.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5, + "bbox_fs": [ + 106, + 228, + 506, + 272 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 281, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 506, + 294 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 506, + 294 + ], + "score": 1.0, + "content": "[51] Eric Mitchell, Charles Lin, Antoine Bosselut, Chelsea Finn, and Christopher D Manning. Fast", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 292, + 507, + 304 + ], + "spans": [ + { + "bbox": [ + 127, + 292, + 507, + 304 + ], + "score": 1.0, + "content": "model editing at scale. In International Conference on Learning Representations (ICLR), 2021.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 302, + 300, + 315 + ], + "spans": [ + { + "bbox": [ + 127, + 302, + 300, + 315 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2110.11309.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 280, + 507, + 315 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 322, + 504, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 335 + ], + "score": 1.0, + "content": "[52] Vaishnavh Nagarajan and J. Zico Kolter. Uniform convergence may be unable to explain", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 126, + 334, + 505, + 347 + ], + "spans": [ + { + "bbox": [ + 126, + 334, + 505, + 347 + ], + "score": 1.0, + "content": "generalization in deep learning. In NeurIPS, 2019. https://proceedings.neurips.cc/", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 126, + 344, + 438, + 357 + ], + "spans": [ + { + "bbox": [ + 126, + 344, + 438, + 357 + ], + "score": 1.0, + "content": "paper/2019/file/05e97c207235d63ceb1db43c60db7bbb-Paper.pdf.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 322, + 505, + 357 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 364, + 507, + 409 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 507, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 507, + 378 + ], + "score": 1.0, + "content": "[53] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 127, + 375, + 507, + 388 + ], + "spans": [ + { + "bbox": [ + 127, + 375, + 507, + 388 + ], + "score": 1.0, + "content": "Reading digits in natural images with unsupervised feature learning. In Advances in Neural In-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 126, + 385, + 508, + 399 + ], + "spans": [ + { + "bbox": [ + 126, + 385, + 508, + 399 + ], + "score": 1.0, + "content": "formation Processing Systems (NeurIPS) Workshops, 2011. https://storage.googleapis.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 127, + 397, + 402, + 410 + ], + "spans": [ + { + "bbox": [ + 127, + 397, + 402, + 410 + ], + "score": 1.0, + "content": "com/pub-tools-public-publication-data/pdf/37648.pdf.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 363, + 508, + 410 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 416, + 504, + 451 + ], + "lines": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "[54] Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 427, + 507, + 440 + ], + "spans": [ + { + "bbox": [ + 126, + 427, + 507, + 440 + ], + "score": 1.0, + "content": "learning? In Advances in Neural Information Processing Systems (NeurIPS), 2020. https:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 127, + 439, + 268, + 451 + ], + "spans": [ + { + "bbox": [ + 127, + 439, + 268, + 451 + ], + "score": 1.0, + "content": "//arxiv.org/abs/2008.11687.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 416, + 507, + 451 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 458, + 504, + 503 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 472 + ], + "score": 1.0, + "content": "[55] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 127, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 127, + 480, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 127, + 480, + 505, + 494 + ], + "score": 1.0, + "content": "style, high-performance deep learning library. Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 491, + 406, + 504 + ], + "spans": [ + { + "bbox": [ + 127, + 491, + 406, + 504 + ], + "score": 1.0, + "content": "Systems (NeurIPS), 2019. https://arxiv.org/abs/1912.01703.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 457, + 506, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 505, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 507, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 507, + 525 + ], + "score": 1.0, + "content": "[56] Hieu Pham, Zihang Dai, Golnaz Ghiasi, Hanxiao Liu, Adams Wei Yu, Minh-Thang Luong,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 127, + 522, + 507, + 534 + ], + "spans": [ + { + "bbox": [ + 127, + 522, + 507, + 534 + ], + "score": 1.0, + "content": "Mingxing Tan, and Quoc V Le. Combined scaling for zero-shot transfer learning, 2021.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 532, + 300, + 545 + ], + "spans": [ + { + "bbox": [ + 127, + 532, + 300, + 545 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2111.10050.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 509, + 507, + 545 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 552, + 506, + 607 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 507, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 507, + 566 + ], + "score": 1.0, + "content": "[57] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agar-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 127, + 563, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 127, + 563, + 506, + 577 + ], + "score": 1.0, + "content": "wal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "spans": [ + { + "bbox": [ + 127, + 574, + 507, + 587 + ], + "score": 1.0, + "content": "Sutskever. Learning transferable visual models from natural language supervision. In Inter-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 126, + 585, + 507, + 598 + ], + "spans": [ + { + "bbox": [ + 126, + 585, + 507, + 598 + ], + "score": 1.0, + "content": "national Conference on Machine Learning (ICML), 2021. https://arxiv.org/abs/2103.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 595, + 159, + 609 + ], + "spans": [ + { + "bbox": [ + 127, + 595, + 159, + 609 + ], + "score": 1.0, + "content": "00020.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 552, + 507, + 609 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 616, + 506, + 650 + ], + "lines": [ + { + "bbox": [ + 105, + 614, + 507, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 197, + 628 + ], + "score": 1.0, + "content": "[58] Colin Raffel.", + "type": "text" + }, + { + "bbox": [ + 233, + 614, + 507, + 630 + ], + "score": 1.0, + "content": "A call to build models like we build open-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 126, + 625, + 504, + 640 + ], + "spans": [ + { + "bbox": [ + 126, + 628, + 159, + 639 + ], + "score": 1.0, + "content": "source", + "type": "text" + }, + { + "bbox": [ + 179, + 625, + 222, + 640 + ], + "score": 1.0, + "content": "software,", + "type": "text" + }, + { + "bbox": [ + 248, + 625, + 276, + 639 + ], + "score": 1.0, + "content": "2021.", + "type": "text" + }, + { + "bbox": [ + 351, + 626, + 504, + 640 + ], + "score": 1.0, + "content": "https://colinraffel.com/blog/", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 126, + 637, + 462, + 650 + ], + "spans": [ + { + "bbox": [ + 126, + 637, + 462, + 650 + ], + "score": 1.0, + "content": "a-call-to-build-models-like-we-build-open-source-software.html.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 105, + 614, + 507, + 650 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 658, + 504, + 692 + ], + "lines": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 505, + 670 + ], + "score": 1.0, + "content": "[59] Vinay Venkatesh Ramasesh, Aitor Lewkowycz, and Ethan Dyer. Effect of scale on catastrophic", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 668, + 506, + 682 + ], + "spans": [ + { + "bbox": [ + 127, + 668, + 506, + 682 + ], + "score": 1.0, + "content": "forgetting in neural networks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 679, + 383, + 693 + ], + "spans": [ + { + "bbox": [ + 127, + 679, + 383, + 693 + ], + "score": 1.0, + "content": "2021. https://openreview.net/forum?id=GhVS8_yPeEa.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 658, + 506, + 693 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 700, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 504, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 504, + 712 + ], + "score": 1.0, + "content": "[60] J. Rapin and O. Teytaud. Nevergrad - A gradient-free optimization platform. https://GitHub.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 710, + 315, + 722 + ], + "spans": [ + { + "bbox": [ + 127, + 710, + 315, + 722 + ], + "score": 1.0, + "content": "com/FacebookResearch/Nevergrad, 2018.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5, + "bbox_fs": [ + 106, + 699, + 504, + 722 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 72, + 504, + 106 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[61] Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "Incremental classifier and representation learning. In Conference on Computer Vision and", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 128, + 95, + 444, + 106 + ], + "spans": [ + { + "bbox": [ + 128, + 95, + 444, + 106 + ], + "score": 1.0, + "content": "Pattern Recognition (CVPR), 2017. https://arxiv.org/abs/1611.07725.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 114, + 504, + 148 + ], + "lines": [ + { + "bbox": [ + 106, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "[62] Marco Tulio Ribeiro and Scott Lundberg. Adaptive testing and debugging of nlp models. In Asso-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 126, + 504, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 126, + 504, + 137 + ], + "score": 1.0, + "content": "ciation for Computational Linguistics (ACL), 2022. https://www.microsoft.com/en-us/", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 136, + 481, + 149 + ], + "spans": [ + { + "bbox": [ + 127, + 136, + 481, + 149 + ], + "score": 1.0, + "content": "research/publication/adaptive-testing-and-debugging-of-nlp-models/.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 156, + 505, + 190 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 507, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 507, + 170 + ], + "score": 1.0, + "content": "[63] Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. Beyond accuracy:", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 127, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "Behavioral testing of NLP models with CheckList. In Association for Computational Linguistics", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 177, + 408, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 177, + 408, + 191 + ], + "score": 1.0, + "content": "(ACL), 2020. https://aclanthology.org/2020.acl-main.442.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 198, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 104, + 196, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 104, + 196, + 506, + 212 + ], + "score": 1.0, + "content": "[64] David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, and Gregory Wayne. Expe-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 208, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 127, + 208, + 505, + 221 + ], + "score": 1.0, + "content": "rience replay for continual learning. In Advances in Neural Information Processing Systems", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 219, + 371, + 231 + ], + "spans": [ + { + "bbox": [ + 127, + 219, + 371, + 231 + ], + "score": 1.0, + "content": "(NeurIPS), 2019. https://arxiv.org/abs/1811.11682.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 239, + 505, + 273 + ], + "lines": [ + { + "bbox": [ + 105, + 238, + 507, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 507, + 252 + ], + "score": 1.0, + "content": "[65] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 128, + 250, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 128, + 250, + 506, + 262 + ], + "score": 1.0, + "content": "Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks, 2016.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 261, + 300, + 273 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 300, + 273 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1606.04671.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 281, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 506, + 293 + ], + "score": 1.0, + "content": "[66] Shibani Santurkar, Dimitris Tsipras, Mahalaxmi Elango, David Bau, Antonio Torralba, and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 292, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 127, + 292, + 505, + 304 + ], + "score": 1.0, + "content": "Aleksander Madry. Editing a classifier by rewriting its prediction rules. In Advances in Neural", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 302, + 503, + 315 + ], + "spans": [ + { + "bbox": [ + 127, + 302, + 503, + 315 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2021. https://arxiv.org/abs/2112.01008.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 322, + 506, + 366 + ], + "lines": [ + { + "bbox": [ + 106, + 322, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 506, + 335 + ], + "score": 1.0, + "content": "[67] Christoph Schuhmann, Richard Vencu, Romain Beaumont, Robert Kaczmarczyk, Clayton", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 333, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 127, + 333, + 506, + 346 + ], + "score": 1.0, + "content": "Mullis, Aarush Katta, Theo Coombes, Jenia Jitsev, and Aran Komatsuzaki. Laion-400m: Open", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 344, + 507, + 357 + ], + "spans": [ + { + "bbox": [ + 127, + 344, + 507, + 357 + ], + "score": 1.0, + "content": "dataset of clip-filtered 400 million image-text pairs, 2021. https://arxiv.org/abs/2111.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 355, + 160, + 367 + ], + "spans": [ + { + "bbox": [ + 127, + 355, + 160, + 367 + ], + "score": 1.0, + "content": "02114.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 506, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 373, + 508, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 508, + 389 + ], + "score": 1.0, + "content": "[68] Sheng Shen, Liunian Harold Li, Hao Tan, Mohit Bansal, Anna Rohrbach, Kai-Wei Chang,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 386, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 127, + 386, + 505, + 398 + ], + "score": 1.0, + "content": "Zhewei Yao, and Kurt Keutzer. How much can clip benefit vision-and-language tasks? In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 396, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 126, + 396, + 505, + 410 + ], + "score": 1.0, + "content": "International Conference on Learning Representations (ICLR), 2022. https://arxiv.org/", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 128, + 408, + 206, + 419 + ], + "spans": [ + { + "bbox": [ + 128, + 408, + 206, + 419 + ], + "score": 1.0, + "content": "abs/2107.06383.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 106, + 427, + 505, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 506, + 442 + ], + "score": 1.0, + "content": "[69] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 439, + 507, + 451 + ], + "spans": [ + { + "bbox": [ + 126, + 439, + 507, + 451 + ], + "score": 1.0, + "content": "generative replay. In Advances in Neural Information Processing Systems (NeurIPS), 2017.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 450, + 300, + 462 + ], + "spans": [ + { + "bbox": [ + 127, + 450, + 300, + 462 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1705.08690.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "[70] Anton Sinitsin, Vsevolod Plokhotnyuk, Dmitriy Pyrkin, Sergei Popov, and Artem Babenko.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 479, + 507, + 494 + ], + "spans": [ + { + "bbox": [ + 126, + 479, + 507, + 494 + ], + "score": 1.0, + "content": "Editable neural networks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 490, + 326, + 504 + ], + "spans": [ + { + "bbox": [ + 127, + 490, + 326, + 504 + ], + "score": 1.0, + "content": "2020. https://arxiv.org/abs/2004.00345.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 506, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "[71] Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. The german traffic sign", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 126, + 522, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 126, + 522, + 506, + 533 + ], + "score": 1.0, + "content": "recognition benchmark: a multi-class classification competition. In International Joint Con-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 127, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "ference on Neural Networks (IJCNN), 2011. https://ieeexplore.ieee.org/document/", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 544, + 169, + 555 + ], + "spans": [ + { + "bbox": [ + 127, + 544, + 169, + 555 + ], + "score": 1.0, + "content": "6033395.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 505, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "score": 1.0, + "content": "[72] Yi-Lin Sung, Varun Nair, and Colin A Raffel. Training neural networks with fixed sparse masks.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 573, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 126, + 573, + 505, + 588 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems (NeurIPS), 2021. https://arxiv.org/", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 128, + 586, + 206, + 597 + ], + "spans": [ + { + "bbox": [ + 128, + 586, + 206, + 597 + ], + "score": 1.0, + "content": "abs/2111.09839.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 605, + 504, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "[73] Yi-Lin Sung, Jaemin Cho, and Mohit Bansal. Vl-adapter: Parameter-efficient transfer learning", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 127, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "for vision-and-language tasks. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 627, + 361, + 639 + ], + "spans": [ + { + "bbox": [ + 127, + 627, + 361, + 639 + ], + "score": 1.0, + "content": "(CVPR), 2022. https://arxiv.org/abs/2112.06825.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 106, + 647, + 505, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 507, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 507, + 661 + ], + "score": 1.0, + "content": "[74] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Re-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 658, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 506, + 671 + ], + "score": 1.0, + "content": "thinking the inception architecture for computer vision. In Conference on Computer Vision and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 669, + 421, + 681 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 421, + 681 + ], + "score": 1.0, + "content": "Pattern Recognition, 2016. https://arxiv.org/abs/1512.00567v3.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "[75] Bart Thomee, David A Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "Damian Borth, and Li-Jia Li. Yfcc100m: The new data in multimedia research. Communications", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 710, + 377, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 710, + 377, + 723 + ], + "score": 1.0, + "content": "of the ACM, 2016. https://arxiv.org/abs/1503.01817.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46 + } + ], + "page_idx": 14, + "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": "15", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 72, + 504, + 106 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "[61] Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 127, + 84, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 127, + 84, + 505, + 96 + ], + "score": 1.0, + "content": "Incremental classifier and representation learning. In Conference on Computer Vision and", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 128, + 95, + 444, + 106 + ], + "spans": [ + { + "bbox": [ + 128, + 95, + 444, + 106 + ], + "score": 1.0, + "content": "Pattern Recognition (CVPR), 2017. https://arxiv.org/abs/1611.07725.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 106, + 72, + 506, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 114, + 504, + 148 + ], + "lines": [ + { + "bbox": [ + 106, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "[62] Marco Tulio Ribeiro and Scott Lundberg. Adaptive testing and debugging of nlp models. In Asso-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 126, + 504, + 137 + ], + "spans": [ + { + "bbox": [ + 128, + 126, + 504, + 137 + ], + "score": 1.0, + "content": "ciation for Computational Linguistics (ACL), 2022. https://www.microsoft.com/en-us/", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 127, + 136, + 481, + 149 + ], + "spans": [ + { + "bbox": [ + 127, + 136, + 481, + 149 + ], + "score": 1.0, + "content": "research/publication/adaptive-testing-and-debugging-of-nlp-models/.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 106, + 113, + 506, + 149 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 156, + 505, + 190 + ], + "lines": [ + { + "bbox": [ + 105, + 154, + 507, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 507, + 170 + ], + "score": 1.0, + "content": "[63] Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. Beyond accuracy:", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 127, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "Behavioral testing of NLP models with CheckList. In Association for Computational Linguistics", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 127, + 177, + 408, + 191 + ], + "spans": [ + { + "bbox": [ + 127, + 177, + 408, + 191 + ], + "score": 1.0, + "content": "(ACL), 2020. https://aclanthology.org/2020.acl-main.442.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 154, + 507, + 191 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 198, + 505, + 231 + ], + "lines": [ + { + "bbox": [ + 104, + 196, + 506, + 212 + ], + "spans": [ + { + "bbox": [ + 104, + 196, + 506, + 212 + ], + "score": 1.0, + "content": "[64] David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, and Gregory Wayne. Expe-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 127, + 208, + 505, + 221 + ], + "spans": [ + { + "bbox": [ + 127, + 208, + 505, + 221 + ], + "score": 1.0, + "content": "rience replay for continual learning. In Advances in Neural Information Processing Systems", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 219, + 371, + 231 + ], + "spans": [ + { + "bbox": [ + 127, + 219, + 371, + 231 + ], + "score": 1.0, + "content": "(NeurIPS), 2019. https://arxiv.org/abs/1811.11682.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 104, + 196, + 506, + 231 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 239, + 505, + 273 + ], + "lines": [ + { + "bbox": [ + 105, + 238, + 507, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 507, + 252 + ], + "score": 1.0, + "content": "[65] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 128, + 250, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 128, + 250, + 506, + 262 + ], + "score": 1.0, + "content": "Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks, 2016.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 261, + 300, + 273 + ], + "spans": [ + { + "bbox": [ + 127, + 261, + 300, + 273 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1606.04671.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 238, + 507, + 273 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 281, + 505, + 315 + ], + "lines": [ + { + "bbox": [ + 105, + 280, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 105, + 280, + 506, + 293 + ], + "score": 1.0, + "content": "[66] Shibani Santurkar, Dimitris Tsipras, Mahalaxmi Elango, David Bau, Antonio Torralba, and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 292, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 127, + 292, + 505, + 304 + ], + "score": 1.0, + "content": "Aleksander Madry. Editing a classifier by rewriting its prediction rules. In Advances in Neural", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 302, + 503, + 315 + ], + "spans": [ + { + "bbox": [ + 127, + 302, + 503, + 315 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2021. https://arxiv.org/abs/2112.01008.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 280, + 506, + 315 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 322, + 506, + 366 + ], + "lines": [ + { + "bbox": [ + 106, + 322, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 506, + 335 + ], + "score": 1.0, + "content": "[67] Christoph Schuhmann, Richard Vencu, Romain Beaumont, Robert Kaczmarczyk, Clayton", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 333, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 127, + 333, + 506, + 346 + ], + "score": 1.0, + "content": "Mullis, Aarush Katta, Theo Coombes, Jenia Jitsev, and Aran Komatsuzaki. Laion-400m: Open", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 344, + 507, + 357 + ], + "spans": [ + { + "bbox": [ + 127, + 344, + 507, + 357 + ], + "score": 1.0, + "content": "dataset of clip-filtered 400 million image-text pairs, 2021. https://arxiv.org/abs/2111.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 355, + 160, + 367 + ], + "spans": [ + { + "bbox": [ + 127, + 355, + 160, + 367 + ], + "score": 1.0, + "content": "02114.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 322, + 507, + 367 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 375, + 506, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 373, + 508, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 508, + 389 + ], + "score": 1.0, + "content": "[68] Sheng Shen, Liunian Harold Li, Hao Tan, Mohit Bansal, Anna Rohrbach, Kai-Wei Chang,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 386, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 127, + 386, + 505, + 398 + ], + "score": 1.0, + "content": "Zhewei Yao, and Kurt Keutzer. How much can clip benefit vision-and-language tasks? In", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 126, + 396, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 126, + 396, + 505, + 410 + ], + "score": 1.0, + "content": "International Conference on Learning Representations (ICLR), 2022. https://arxiv.org/", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 128, + 408, + 206, + 419 + ], + "spans": [ + { + "bbox": [ + 128, + 408, + 206, + 419 + ], + "score": 1.0, + "content": "abs/2107.06383.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 373, + 508, + 419 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 427, + 505, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 506, + 442 + ], + "score": 1.0, + "content": "[69] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 126, + 439, + 507, + 451 + ], + "spans": [ + { + "bbox": [ + 126, + 439, + 507, + 451 + ], + "score": 1.0, + "content": "generative replay. In Advances in Neural Information Processing Systems (NeurIPS), 2017.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 127, + 450, + 300, + 462 + ], + "spans": [ + { + "bbox": [ + 127, + 450, + 300, + 462 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/1705.08690.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 425, + 507, + 462 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 503 + ], + "lines": [ + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 482 + ], + "score": 1.0, + "content": "[70] Anton Sinitsin, Vsevolod Plokhotnyuk, Dmitriy Pyrkin, Sergei Popov, and Artem Babenko.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 126, + 479, + 507, + 494 + ], + "spans": [ + { + "bbox": [ + 126, + 479, + 507, + 494 + ], + "score": 1.0, + "content": "Editable neural networks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 490, + 326, + 504 + ], + "spans": [ + { + "bbox": [ + 127, + 490, + 326, + 504 + ], + "score": 1.0, + "content": "2020. https://arxiv.org/abs/2004.00345.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 469, + 507, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 511, + 506, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "[71] Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. The german traffic sign", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 126, + 522, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 126, + 522, + 506, + 533 + ], + "score": 1.0, + "content": "recognition benchmark: a multi-class classification competition. In International Joint Con-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 127, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "ference on Neural Networks (IJCNN), 2011. https://ieeexplore.ieee.org/document/", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 544, + 169, + 555 + ], + "spans": [ + { + "bbox": [ + 127, + 544, + 169, + 555 + ], + "score": 1.0, + "content": "6033395.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 510, + 506, + 555 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 505, + 597 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 506, + 576 + ], + "score": 1.0, + "content": "[72] Yi-Lin Sung, Varun Nair, and Colin A Raffel. Training neural networks with fixed sparse masks.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 126, + 573, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 126, + 573, + 505, + 588 + ], + "score": 1.0, + "content": "Advances in Neural Information Processing Systems (NeurIPS), 2021. https://arxiv.org/", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 128, + 586, + 206, + 597 + ], + "spans": [ + { + "bbox": [ + 128, + 586, + 206, + 597 + ], + "score": 1.0, + "content": "abs/2111.09839.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 563, + 506, + 597 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 605, + 504, + 639 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "[73] Yi-Lin Sung, Jaemin Cho, and Mohit Bansal. Vl-adapter: Parameter-efficient transfer learning", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 127, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 127, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "for vision-and-language tasks. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 627, + 361, + 639 + ], + "spans": [ + { + "bbox": [ + 127, + 627, + 361, + 639 + ], + "score": 1.0, + "content": "(CVPR), 2022. https://arxiv.org/abs/2112.06825.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 604, + 506, + 639 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 647, + 505, + 681 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 507, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 507, + 661 + ], + "score": 1.0, + "content": "[74] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Re-", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 127, + 658, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 127, + 658, + 506, + 671 + ], + "score": 1.0, + "content": "thinking the inception architecture for computer vision. In Conference on Computer Vision and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 127, + 669, + 421, + 681 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 421, + 681 + ], + "score": 1.0, + "content": "Pattern Recognition, 2016. https://arxiv.org/abs/1512.00567v3.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 646, + 507, + 681 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "[75] Bart Thomee, David A Shamma, Gerald Friedland, Benjamin Elizalde, Karl Ni, Douglas Poland,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 127, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "Damian Borth, and Li-Jia Li. Yfcc100m: The new data in multimedia research. Communications", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 710, + 377, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 710, + 377, + 723 + ], + "score": 1.0, + "content": "of the ACM, 2016. https://arxiv.org/abs/1503.01817.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 687, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 73, + 506, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 507, + 84 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 507, + 84 + ], + "score": 1.0, + "content": "[76] Sebastian Thrun. Lifelong learning algorithms. In Learning to learn, 1998. https://link.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 83, + 387, + 96 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 387, + 96 + ], + "score": 1.0, + "content": "springer.com/chapter/10.1007/978-1-4615-5529-2_8.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 101, + 505, + 136 + ], + "lines": [ + { + "bbox": [ + 105, + 101, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 101, + 506, + 115 + ], + "score": 1.0, + "content": "[77] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 126, + 113, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 126, + 113, + 505, + 125 + ], + "score": 1.0, + "content": "Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in Neural Information", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 124, + 452, + 136 + ], + "spans": [ + { + "bbox": [ + 128, + 124, + 452, + 136 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017. https://arxiv.org/abs/1706.03762.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 108, + 142, + 504, + 176 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "score": 1.0, + "content": "[78] Johannes von Oswald, Christian Henning, João Sacramento, and Benjamin F. Grewe. Continual", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 153, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 127, + 153, + 506, + 166 + ], + "score": 1.0, + "content": "learning with hypernetworks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 163, + 379, + 177 + ], + "spans": [ + { + "bbox": [ + 127, + 163, + 379, + 177 + ], + "score": 1.0, + "content": "2020. https://openreview.net/forum?id=SJgwNerKvB.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 105, + 182, + 505, + 205 + ], + "lines": [ + { + "bbox": [ + 105, + 181, + 504, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 205, + 195 + ], + "score": 1.0, + "content": "[79] Ross Wightman.", + "type": "text" + }, + { + "bbox": [ + 223, + 181, + 331, + 195 + ], + "score": 1.0, + "content": "Pytorch image models.", + "type": "text" + }, + { + "bbox": [ + 351, + 182, + 504, + 195 + ], + "score": 1.0, + "content": "https://github.com/rwightman/", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 126, + 194, + 264, + 205 + ], + "spans": [ + { + "bbox": [ + 126, + 194, + 264, + 205 + ], + "score": 1.0, + "content": "pytorch-image-models, 2019.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 212, + 505, + 246 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 506, + 224 + ], + "score": 1.0, + "content": "[80] Mitchell Wortsman, Vivek Ramanujan, Rosanne Liu, Aniruddha Kembhavi, Mohammad Raste-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 223, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 127, + 223, + 506, + 235 + ], + "score": 1.0, + "content": "gari, Jason Yosinski, and Ali Farhadi. Supermasks in superposition. In Advances in Neural", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 128, + 233, + 504, + 247 + ], + "spans": [ + { + "bbox": [ + 128, + 233, + 504, + 247 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2020. https://arxiv.org/abs/2006.14769.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 252, + 506, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "score": 1.0, + "content": "[81] Mitchell Wortsman, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael Gontijo-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 263, + 507, + 276 + ], + "spans": [ + { + "bbox": [ + 127, + 263, + 507, + 276 + ], + "score": 1.0, + "content": "Lopes, Ari S Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 126, + 273, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 126, + 273, + 506, + 288 + ], + "score": 1.0, + "content": "Model soups: averaging weights of multiple fine-tuned models improves accuracy without", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 285, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 127, + 285, + 506, + 297 + ], + "score": 1.0, + "content": "increasing inference time. In International Conference on Machine Learning (ICML), 2022.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 296, + 299, + 308 + ], + "spans": [ + { + "bbox": [ + 127, + 296, + 299, + 308 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2203.05482.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 314, + 506, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "[82] Mitchell Wortsman, Gabriel Ilharco, Mike Li, Jong Wook Kim, Hannaneh Hajishirzi, Ali", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 326, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 127, + 326, + 506, + 338 + ], + "score": 1.0, + "content": "Farhadi, Hongseok Namkoong, and Ludwig Schmidt. Robust fine-tuning of zero-shot models.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 337, + 507, + 349 + ], + "spans": [ + { + "bbox": [ + 127, + 337, + 507, + 349 + ], + "score": 1.0, + "content": "In Conference on Computer Vision and Pattern Recognition (CVPR), 2022. https://arxiv.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 348, + 227, + 358 + ], + "spans": [ + { + "bbox": [ + 127, + 348, + 227, + 358 + ], + "score": 1.0, + "content": "org/abs/2109.01903.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 105, + 366, + 505, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 365, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 506, + 378 + ], + "score": 1.0, + "content": "[83] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 127, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "benchmarking machine learning algorithms, 2017. https://arxiv.org/abs/1708.07747.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 395, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 507, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 507, + 408 + ], + "score": 1.0, + "content": "[84] Jianxiong Xiao, Krista A Ehinger, James Hays, Antonio Torralba, and Aude Oliva. Sun database:", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 127, + 406, + 505, + 419 + ], + "spans": [ + { + "bbox": [ + 127, + 406, + 505, + 419 + ], + "score": 1.0, + "content": "Exploring a large collection of scene categories. International Journal of Computer Vision", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 416, + 502, + 431 + ], + "spans": [ + { + "bbox": [ + 126, + 416, + 502, + 431 + ], + "score": 1.0, + "content": "(IJCV), 2016. https://link.springer.com/article/10.1007/s11263-014-0748-y.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 436, + 504, + 469 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 449 + ], + "score": 1.0, + "content": "[85] Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 128, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 128, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "dynamically expandable networks. In International Conference on Learning Representations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 458, + 358, + 470 + ], + "spans": [ + { + "bbox": [ + 127, + 458, + 358, + 470 + ], + "score": 1.0, + "content": "(ICLR), 2018. https://arxiv.org/abs/1708.01547.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 476, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 489 + ], + "score": 1.0, + "content": "[86] Jiahui Yu, Zirui Wang, Vijay Vasudevan, Legg Yeung, Mojtaba Seyedhosseini, and Yonghui", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 486, + 507, + 500 + ], + "spans": [ + { + "bbox": [ + 127, + 486, + 507, + 500 + ], + "score": 1.0, + "content": "Wu. Coca: Contrastive captioners are image-text foundation models, 2022. https://arxiv.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 498, + 227, + 509 + ], + "spans": [ + { + "bbox": [ + 127, + 498, + 227, + 509 + ], + "score": 1.0, + "content": "org/abs/2205.01917.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "[87] Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 127, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "intelligence. In International Conference on Machine Learning (ICML), 2017. https://", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 538, + 258, + 550 + ], + "spans": [ + { + "bbox": [ + 127, + 538, + 258, + 550 + ], + "score": 1.0, + "content": "arxiv.org/abs/1703.04200.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 106, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "[88] Xiaohua Zhai, Xiao Wang, Basil Mustafa, Andreas Steiner, Daniel Keysers, Alexander", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 127, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "Kolesnikov, and Lucas Beyer. Lit: Zero-shot transfer with locked-image text tuning. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 578, + 508, + 591 + ], + "spans": [ + { + "bbox": [ + 127, + 578, + 508, + 591 + ], + "score": 1.0, + "content": "Conference on Computer Vision and Pattern Recognition (CVPR), 2022. https://arxiv.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 590, + 227, + 601 + ], + "spans": [ + { + "bbox": [ + 127, + 590, + 227, + 601 + ], + "score": 1.0, + "content": "org/abs/2111.07991.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 105, + 608, + 505, + 642 + ], + "lines": [ + { + "bbox": [ + 106, + 607, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 506, + 621 + ], + "score": 1.0, + "content": "[89] Renrui Zhang, Rongyao Fang, Peng Gao, Wei Zhang, Kunchang Li, Jifeng Dai, Yu Qiao, and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 618, + 507, + 633 + ], + "spans": [ + { + "bbox": [ + 127, + 618, + 507, + 633 + ], + "score": 1.0, + "content": "Hongsheng Li. Tip-adapter: Training-free clip-adapter for better vision-language modeling,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 127, + 629, + 326, + 642 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 326, + 642 + ], + "score": 1.0, + "content": "2021. https://arxiv.org/abs/2111.03930.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 105, + 648, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 662 + ], + "score": 1.0, + "content": "[90] Hattie Zhou, Ankit Vani, Hugo Larochelle, and Aaron Courville. Fortuitous forgetting in", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 126, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 126, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "connectionist networks. In International Conference on Learning Representations (ICLR), 2022.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 669, + 300, + 683 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 300, + 683 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2202.00155.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 703 + ], + "score": 1.0, + "content": "[91] Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu. Conditional prompt learning", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "for vision-language models. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 127, + 711, + 362, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 362, + 723 + ], + "score": 1.0, + "content": "(CVPR), 2022. https://arxiv.org/abs/2203.05557.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + } + ], + "page_idx": 15, + "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": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 73, + 506, + 95 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 507, + 84 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 507, + 84 + ], + "score": 1.0, + "content": "[76] Sebastian Thrun. Lifelong learning algorithms. In Learning to learn, 1998. https://link.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 126, + 83, + 387, + 96 + ], + "spans": [ + { + "bbox": [ + 126, + 83, + 387, + 96 + ], + "score": 1.0, + "content": "springer.com/chapter/10.1007/978-1-4615-5529-2_8.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 72, + 507, + 96 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 101, + 505, + 136 + ], + "lines": [ + { + "bbox": [ + 105, + 101, + 506, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 101, + 506, + 115 + ], + "score": 1.0, + "content": "[77] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 126, + 113, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 126, + 113, + 505, + 125 + ], + "score": 1.0, + "content": "Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in Neural Information", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 128, + 124, + 452, + 136 + ], + "spans": [ + { + "bbox": [ + 128, + 124, + 452, + 136 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017. https://arxiv.org/abs/1706.03762.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 101, + 506, + 136 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 142, + 504, + 176 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "score": 1.0, + "content": "[78] Johannes von Oswald, Christian Henning, João Sacramento, and Benjamin F. Grewe. Continual", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 127, + 153, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 127, + 153, + 506, + 166 + ], + "score": 1.0, + "content": "learning with hypernetworks. In International Conference on Learning Representations (ICLR),", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 127, + 163, + 379, + 177 + ], + "spans": [ + { + "bbox": [ + 127, + 163, + 379, + 177 + ], + "score": 1.0, + "content": "2020. https://openreview.net/forum?id=SJgwNerKvB.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 142, + 506, + 177 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 182, + 505, + 205 + ], + "lines": [ + { + "bbox": [ + 105, + 181, + 504, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 205, + 195 + ], + "score": 1.0, + "content": "[79] Ross Wightman.", + "type": "text" + }, + { + "bbox": [ + 223, + 181, + 331, + 195 + ], + "score": 1.0, + "content": "Pytorch image models.", + "type": "text" + }, + { + "bbox": [ + 351, + 182, + 504, + 195 + ], + "score": 1.0, + "content": "https://github.com/rwightman/", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 126, + 194, + 264, + 205 + ], + "spans": [ + { + "bbox": [ + 126, + 194, + 264, + 205 + ], + "score": 1.0, + "content": "pytorch-image-models, 2019.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 181, + 504, + 205 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 212, + 505, + 246 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 506, + 224 + ], + "score": 1.0, + "content": "[80] Mitchell Wortsman, Vivek Ramanujan, Rosanne Liu, Aniruddha Kembhavi, Mohammad Raste-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 127, + 223, + 506, + 235 + ], + "spans": [ + { + "bbox": [ + 127, + 223, + 506, + 235 + ], + "score": 1.0, + "content": "gari, Jason Yosinski, and Ali Farhadi. Supermasks in superposition. In Advances in Neural", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 128, + 233, + 504, + 247 + ], + "spans": [ + { + "bbox": [ + 128, + 233, + 504, + 247 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2020. https://arxiv.org/abs/2006.14769.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11, + "bbox_fs": [ + 106, + 212, + 506, + 247 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 252, + 506, + 308 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 265 + ], + "score": 1.0, + "content": "[81] Mitchell Wortsman, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael Gontijo-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 127, + 263, + 507, + 276 + ], + "spans": [ + { + "bbox": [ + 127, + 263, + 507, + 276 + ], + "score": 1.0, + "content": "Lopes, Ari S Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 126, + 273, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 126, + 273, + 506, + 288 + ], + "score": 1.0, + "content": "Model soups: averaging weights of multiple fine-tuned models improves accuracy without", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 127, + 285, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 127, + 285, + 506, + 297 + ], + "score": 1.0, + "content": "increasing inference time. In International Conference on Machine Learning (ICML), 2022.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 127, + 296, + 299, + 308 + ], + "spans": [ + { + "bbox": [ + 127, + 296, + 299, + 308 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2203.05482.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15, + "bbox_fs": [ + 106, + 253, + 507, + 308 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 314, + 506, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 314, + 506, + 327 + ], + "score": 1.0, + "content": "[82] Mitchell Wortsman, Gabriel Ilharco, Mike Li, Jong Wook Kim, Hannaneh Hajishirzi, Ali", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 127, + 326, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 127, + 326, + 506, + 338 + ], + "score": 1.0, + "content": "Farhadi, Hongseok Namkoong, and Ludwig Schmidt. Robust fine-tuning of zero-shot models.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 127, + 337, + 507, + 349 + ], + "spans": [ + { + "bbox": [ + 127, + 337, + 507, + 349 + ], + "score": 1.0, + "content": "In Conference on Computer Vision and Pattern Recognition (CVPR), 2022. https://arxiv.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 127, + 348, + 227, + 358 + ], + "spans": [ + { + "bbox": [ + 127, + 348, + 227, + 358 + ], + "score": 1.0, + "content": "org/abs/2109.01903.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 314, + 507, + 358 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 366, + 505, + 389 + ], + "lines": [ + { + "bbox": [ + 106, + 365, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 506, + 378 + ], + "score": 1.0, + "content": "[83] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 127, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "benchmarking machine learning algorithms, 2017. https://arxiv.org/abs/1708.07747.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 365, + 506, + 388 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 395, + 504, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 507, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 507, + 408 + ], + "score": 1.0, + "content": "[84] Jianxiong Xiao, Krista A Ehinger, James Hays, Antonio Torralba, and Aude Oliva. Sun database:", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 127, + 406, + 505, + 419 + ], + "spans": [ + { + "bbox": [ + 127, + 406, + 505, + 419 + ], + "score": 1.0, + "content": "Exploring a large collection of scene categories. International Journal of Computer Vision", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 126, + 416, + 502, + 431 + ], + "spans": [ + { + "bbox": [ + 126, + 416, + 502, + 431 + ], + "score": 1.0, + "content": "(IJCV), 2016. https://link.springer.com/article/10.1007/s11263-014-0748-y.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 106, + 394, + 507, + 431 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 436, + 504, + 469 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 505, + 449 + ], + "score": 1.0, + "content": "[85] Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 128, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 128, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "dynamically expandable networks. In International Conference on Learning Representations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 127, + 458, + 358, + 470 + ], + "spans": [ + { + "bbox": [ + 127, + 458, + 358, + 470 + ], + "score": 1.0, + "content": "(ICLR), 2018. https://arxiv.org/abs/1708.01547.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 106, + 435, + 505, + 470 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 476, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 489 + ], + "score": 1.0, + "content": "[86] Jiahui Yu, Zirui Wang, Vijay Vasudevan, Legg Yeung, Mojtaba Seyedhosseini, and Yonghui", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 127, + 486, + 507, + 500 + ], + "spans": [ + { + "bbox": [ + 127, + 486, + 507, + 500 + ], + "score": 1.0, + "content": "Wu. Coca: Contrastive captioners are image-text foundation models, 2022. https://arxiv.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 127, + 498, + 227, + 509 + ], + "spans": [ + { + "bbox": [ + 127, + 498, + 227, + 509 + ], + "score": 1.0, + "content": "org/abs/2205.01917.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31, + "bbox_fs": [ + 106, + 475, + 507, + 509 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 516, + 504, + 550 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 529 + ], + "score": 1.0, + "content": "[87] Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 127, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 127, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "intelligence. In International Conference on Machine Learning (ICML), 2017. https://", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 127, + 538, + 258, + 550 + ], + "spans": [ + { + "bbox": [ + 127, + 538, + 258, + 550 + ], + "score": 1.0, + "content": "arxiv.org/abs/1703.04200.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 515, + 505, + 550 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 556, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "[88] Xiaohua Zhai, Xiao Wang, Basil Mustafa, Andreas Steiner, Daniel Keysers, Alexander", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 127, + 568, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 127, + 568, + 505, + 579 + ], + "score": 1.0, + "content": "Kolesnikov, and Lucas Beyer. Lit: Zero-shot transfer with locked-image text tuning. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 127, + 578, + 508, + 591 + ], + "spans": [ + { + "bbox": [ + 127, + 578, + 508, + 591 + ], + "score": 1.0, + "content": "Conference on Computer Vision and Pattern Recognition (CVPR), 2022. https://arxiv.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 127, + 590, + 227, + 601 + ], + "spans": [ + { + "bbox": [ + 127, + 590, + 227, + 601 + ], + "score": 1.0, + "content": "org/abs/2111.07991.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5, + "bbox_fs": [ + 106, + 556, + 508, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 608, + 505, + 642 + ], + "lines": [ + { + "bbox": [ + 106, + 607, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 506, + 621 + ], + "score": 1.0, + "content": "[89] Renrui Zhang, Rongyao Fang, Peng Gao, Wei Zhang, Kunchang Li, Jifeng Dai, Yu Qiao, and", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 127, + 618, + 507, + 633 + ], + "spans": [ + { + "bbox": [ + 127, + 618, + 507, + 633 + ], + "score": 1.0, + "content": "Hongsheng Li. Tip-adapter: Training-free clip-adapter for better vision-language modeling,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 127, + 629, + 326, + 642 + ], + "spans": [ + { + "bbox": [ + 127, + 629, + 326, + 642 + ], + "score": 1.0, + "content": "2021. https://arxiv.org/abs/2111.03930.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41, + "bbox_fs": [ + 106, + 607, + 507, + 642 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 648, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 506, + 662 + ], + "score": 1.0, + "content": "[90] Hattie Zhou, Ankit Vani, Hugo Larochelle, and Aaron Courville. Fortuitous forgetting in", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 126, + 659, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 126, + 659, + 506, + 672 + ], + "score": 1.0, + "content": "connectionist networks. In International Conference on Learning Representations (ICLR), 2022.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 127, + 669, + 300, + 683 + ], + "spans": [ + { + "bbox": [ + 127, + 669, + 300, + 683 + ], + "score": 1.0, + "content": "https://arxiv.org/abs/2202.00155.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 647, + 506, + 683 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 506, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 703 + ], + "score": 1.0, + "content": "[91] Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu. Conditional prompt learning", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 127, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 127, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "for vision-language models. In Conference on Computer Vision and Pattern Recognition", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 127, + 711, + 362, + 723 + ], + "spans": [ + { + "bbox": [ + 127, + 711, + 362, + 723 + ], + "score": 1.0, + "content": "(CVPR), 2022. https://arxiv.org/abs/2203.05557.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 687, + 505, + 723 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file