diff --git "a/2023/Trainable Projected Gradient Method for Robust Fine-Tuning/layout.json" "b/2023/Trainable Projected Gradient Method for Robust Fine-Tuning/layout.json" new file mode 100644--- /dev/null +++ "b/2023/Trainable Projected Gradient Method for Robust Fine-Tuning/layout.json" @@ -0,0 +1,9156 @@ +{ + "pdf_info": [ + { + "para_blocks": [ + { + "bbox": [ + 107, + 103, + 487, + 121 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 107, + 103, + 487, + 121 + ], + "spans": [ + { + "bbox": [ + 107, + 103, + 487, + 121 + ], + "type": "text", + "content": "Trainable Projected Gradient Method for Robust Fine-tuning" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 169, + 141, + 424, + 172 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 169, + 141, + 424, + 172 + ], + "spans": [ + { + "bbox": [ + 169, + 141, + 424, + 172 + ], + "type": "text", + "content": "Junjiao Tian\\*1 Xiaoliang Dai2 Chih-Yao Ma2 Zecheng He2 Yen-Cheng Liu1 Zsolt Kira" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 195, + 184, + 399, + 200 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 195, + 184, + 399, + 200 + ], + "spans": [ + { + "bbox": [ + 195, + 184, + 399, + 200 + ], + "type": "text", + "content": "1Georgia Institute of Technology 2Meta" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 143, + 226, + 192, + 239 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 143, + 226, + 192, + 239 + ], + "spans": [ + { + "bbox": [ + 143, + 226, + 192, + 239 + ], + "type": "text", + "content": "Abstract" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "spans": [ + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "text", + "content": "Recent studies on transfer learning have shown that selectively fine-tuning a subset of layers or customizing different learning rates for each layer can greatly improve robustness to out-of-distribution (OOD) data and retain generalization capability in the pre-trained models. However, most of these methods employ manually crafted heuristics or expensive hyper-parameter searches, which prevent them from scaling up to large datasets and neural networks. To solve this problem, we propose Trainable Projected Gradient Method (TPGM) to automatically learn the constraint imposed for each layer for a fine-grained fine-tuning regularization. This is motivated by formulating fine-tuning as a bi-level constrained optimization problem. Specifically, TPGM maintains a set of projection radii, i.e., distance constraints between the fine-tuned model and the pretrained model, for each layer, and enforces them through weight projections. To learn the constraints, we propose a bi-level optimization to automatically learn the best set of projection radii in an end-to-end manner. Theoretically, we show that the bi-level optimization formulation is the key to learning different constraints for each layer. Empirically, with little hyper-parameter search cost, TPGM outperforms existing fine-tuning methods in OOD performance while matching the best in-distribution (ID) performance. For example, when fine-tuned on DomainNet-Real and ImageNet, compared to vanilla fine-tuning, TPGM shows " + }, + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "inline_equation", + "content": "22\\%" + }, + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "inline_equation", + "content": "10\\%" + }, + { + "bbox": [ + 46, + 252, + 290, + 601 + ], + "type": "text", + "content": " relative OOD improvement respectively on their sketch counterparts. Code is available at https://github.com/PotatoTian/TPGM." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 47, + 624, + 128, + 637 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 624, + 128, + 637 + ], + "spans": [ + { + "bbox": [ + 47, + 624, + 128, + 637 + ], + "type": "text", + "content": "1. Introduction" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 47, + 644, + 287, + 693 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 644, + 287, + 693 + ], + "spans": [ + { + "bbox": [ + 47, + 644, + 287, + 693 + ], + "type": "text", + "content": "Improving out-of-distribution (OOD) robustness such that a vision model can be trusted reliably across a variety of conditions beyond the in-distribution (ID) training data has been a central research topic in deep learning. For example," + } + ] + } + ], + "index": 8 + }, + { + "type": "image", + "bbox": [ + 317, + 225, + 538, + 335 + ], + "blocks": [ + { + "bbox": [ + 317, + 225, + 538, + 335 + ], + "lines": [ + { + "bbox": [ + 317, + 225, + 538, + 335 + ], + "spans": [ + { + "bbox": [ + 317, + 225, + 538, + 335 + ], + "type": "image", + "image_path": "8b5a900c65745fdfec7f8951f7a44c9f2a8691a9bd6721f007f21b71ee88df48.jpg" + } + ] + } + ], + "index": 9, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "lines": [ + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "spans": [ + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "text", + "content": "Figure 1. Illustration of TPGM. TPGM learns different weight projection radii, " + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "text", + "content": ", for each layer between a fine-tuned model " + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "inline_equation", + "content": "\\theta_{t}" + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "text", + "content": " and a pre-trained model " + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "text", + "content": " and enforces the constraints through projection to obtain a projected model " + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "inline_equation", + "content": "\\widetilde{\\theta}" + }, + { + "bbox": [ + 305, + 347, + 547, + 392 + ], + "type": "text", + "content": "." + } + ] + } + ], + "index": 10, + "angle": 0, + "type": "image_caption" + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 413, + 546, + 557 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 413, + 546, + 557 + ], + "spans": [ + { + "bbox": [ + 304, + 413, + 546, + 557 + ], + "type": "text", + "content": "domain adaptation [39, 46], domain generalization [25, 50], and out-of-distribution calibration [33] are examples of related fields. More recently, large pre-trained models, such as CLIP [28] (pre-trained on 400M image-text pairs), have demonstrated large gains in OOD robustness, thanks to the ever-increasing amount of pre-training data as well as effective architectures and optimization methods. However, fine-tuning such models to other tasks generally results in worse OOD generalization as the model over-fits to the new data and forgets the pre-trained features [28]. A natural goal is to preserve the generalization capability acquired by the pre-trained model when fine-tuning it to a downstream task." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 558, + 547, + 713 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 558, + 547, + 713 + ], + "spans": [ + { + "bbox": [ + 304, + 558, + 547, + 713 + ], + "type": "text", + "content": "A recent empirical study shows that aggressive fin-tuning strategies such as using a large learning rate can decrease OOD robustness [41]. We hypothesize that the forgetting of the generalization capability of the pre-trained model in the course of fine-tuning is due to unconstrained optimization on the new training data [44]. This conjecture is not surprising, because several prior works, even though they did not focus on OOD robustness, have discovered that encouraging a close distance to the pre-trained model weights can improve ID generalization, i.e., avoiding over-fitting to the training data [9,44]. Similarly, if suitable distance constraints are enforced, we expect the model to behave more like the pre-trained model and thus retain" + } + ] + } + ], + "index": 12 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 65, + 2, + 111, + 34 + ], + "type": "header", + "angle": 0, + "lines": [ + { + "bbox": [ + 65, + 2, + 111, + 34 + ], + "spans": [ + { + "bbox": [ + 65, + 2, + 111, + 34 + ], + "type": "text", + "content": "CVF" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 145, + 0, + 496, + 37 + ], + "type": "header", + "angle": 0, + "lines": [ + { + "bbox": [ + 145, + 0, + 496, + 37 + ], + "spans": [ + { + "bbox": [ + 145, + 0, + 496, + 37 + ], + "type": "text", + "content": "This CVPR paper is the Open Access version, provided by the Computer Vision Foundation. Except for this watermark, it is identical to the accepted version; the final published version of the proceedings is available on IEEE Xplore." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 58, + 702, + 212, + 713 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 58, + 702, + 212, + 713 + ], + "spans": [ + { + "bbox": [ + 58, + 702, + 212, + 713 + ], + "type": "text", + "content": "*Work partially done during internship at Meta." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7836" + } + ] + } + ], + "index": 14 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 0 + }, + { + "para_blocks": [ + { + "bbox": [ + 46, + 72, + 287, + 95 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 72, + 287, + 95 + ], + "spans": [ + { + "bbox": [ + 46, + 72, + 287, + 95 + ], + "type": "text", + "content": "more of its generalization capability. The question is where to enforce distance constraints and how to optimize them?" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 46, + 97, + 289, + 360 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 97, + 289, + 360 + ], + "spans": [ + { + "bbox": [ + 46, + 97, + 289, + 360 + ], + "type": "text", + "content": "Several works have demonstrated the importance of treating each layer differently during fine-tuning. For example, a new work [22] discovers that selectively fine-tuning a subset of layers can lead to improved robustness to distribution shift. Another work [31] shows that optimizing a different learning rate for each layer is beneficial for few-shot learning. Therefore, we propose to enforce a different constraint for each layer. However, existing works either use manually crafted heuristics or expensive hyper-parameter search, which prevent them from scaling up to large datasets and neural networks. For example, the prior work [31] using evolutionary search for hyperparameters can only scale up to a custom 6-layer ConvNet and a ResNet-12 for few-shot learning. The computation and time for searching hyper-parameters become increasingly infeasible for larger datasets, let alone scaling up the combinatorial search space to all layers. For example, a ViT-base [37] model has 154 trainable parameter groups including both weights, biases, and embeddings1. This leads to a search space with more than " + }, + { + "bbox": [ + 46, + 97, + 289, + 360 + ], + "type": "inline_equation", + "content": "10^{45}" + }, + { + "bbox": [ + 46, + 97, + 289, + 360 + ], + "type": "text", + "content": " combinations even if we allow only two choices per constraint parameter, which makes the search prohibitively expensive." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "spans": [ + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": "tian2021geometricTo solve this problem, we propose a trainable projected gradient method (TPGM) to support layer-wise regularization optimization. Specifically, TPGM adopts trainable weight projection constraints " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": ", which we refer to as projection radii, and incorporates them in the forward pass of the main model to optimize. Intuitively, as shown in Fig. 1, TPGM maintains a set of weight projection radii " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": " i.e., the distance between the pre-trained model " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "(\\theta_0)" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": " and the current fine-tuned model " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "(\\theta_t)" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": ", for each layer of a neural network and updates them. The projection radii control how much \"freedom\" each layer has to grow. For example, if the model weights increase outside of the norm ball defined by " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "inline_equation", + "content": "\\| \\cdot \\|" + }, + { + "bbox": [ + 46, + 361, + 289, + 600 + ], + "type": "text", + "content": ", the projection operator will project them back to be within the constraints. To learn the weight projection radii in a principled manner, we propose to use alternating optimization between the model weights and the projection radii, motivated by formulating fine-tuning as a bi-level constrained problem (Sec. 3.1). We theoretically show that the bi-level formulation is the key to learning constraints for each layer (Sec. 3.4)." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 46, + 600, + 288, + 685 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 600, + 288, + 685 + ], + "spans": [ + { + "bbox": [ + 46, + 600, + 288, + 685 + ], + "type": "text", + "content": "Empirically, we conduct thorough experiments on large-scale datasets, DomainNet [27] and ImageNet [4], using different architectures. Under the premise of preserving ID performance, i.e., OOD robustness should not come at the expense of worse ID accuracy, TPGM outperforms existing approaches with little effort for hyper-parameter tuning. Further analysis of the learned projection radii reveals" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 304, + 72, + 547, + 168 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 72, + 547, + 168 + ], + "spans": [ + { + "bbox": [ + 304, + 72, + 547, + 168 + ], + "type": "text", + "content": "that lower layers (layers closer to the input) in a network require stronger regularization while higher layers (layers closer to the output) need more flexibility. This observation is in line with the common belief that lower layers learn more general features while higher layers specialize to each dataset [26, 29, 41, 45]. Therefore, when conducting transfer learning such as fine-tuning, we need to treat each layer differently. Our contributions are summarized below." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 317, + 177, + 545, + 312 + ], + "type": "list", + "angle": 0, + "index": 8, + "blocks": [ + { + "bbox": [ + 317, + 177, + 545, + 225 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 317, + 177, + 545, + 225 + ], + "spans": [ + { + "bbox": [ + 317, + 177, + 545, + 225 + ], + "type": "text", + "content": "- We propose a trainable projected gradient method (TPGM) for fine-tuning to automatically learn the distance constraints for each layer in a neural network during fine-tuning." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 317, + 233, + 545, + 269 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 317, + 233, + 545, + 269 + ], + "spans": [ + { + "bbox": [ + 317, + 233, + 545, + 269 + ], + "type": "text", + "content": "- We conduct experiments on different datasets and architectures to show significantly improved OOD generalization while matching ID performance." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 317, + 276, + 545, + 312 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 317, + 276, + 545, + 312 + ], + "spans": [ + { + "bbox": [ + 317, + 276, + 545, + 312 + ], + "type": "text", + "content": "- We theoretically study TPGM using linear models to show that bi-level optimization is the key to learning different constraints for each layer" + } + ] + } + ], + "index": 7 + } + ], + "sub_type": "text" + }, + { + "bbox": [ + 306, + 323, + 397, + 335 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 323, + 397, + 335 + ], + "spans": [ + { + "bbox": [ + 306, + 323, + 397, + 335 + ], + "type": "text", + "content": "2. Related Works" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "spans": [ + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": "Fine-tuning to Boost ID Performance. SpotTune [11] introduces an additional policy network, which outputs a linear interpolation ratio between the pre-trained model " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "(\\theta_0)" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": " and fine-tuned model " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "(\\theta_t)" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": " based on the input. Instead of directly regularizing the weight space, DELTA [23] proposes to regularize the output (feature maps) of " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": ". However, SpotTune introduces an additional network and needs to keep both the pre-trained model and fine-tuned model for inference. DELTA specifically regularizes feature maps generated by convolution layers. In this work, we focus more on general methods, which do not increase inference costs and are applicable to a broader range of models. L2-SP [44] proposes an explicit inductive bias for fine-tuning. Specifically, it uses an L2 regularization to minimize the distance between " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": ". Most recently, MARS-SP [8] adopts the projected gradient method (PGM) to constrain " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": " within a small sphere centered on the pre-trained model " + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 304, + 342, + 545, + 617 + ], + "type": "text", + "content": ". MARS-SP has shown great performance against its prior works. However, we find it very sensitive to hyperparameter tuning. Nonetheless, our work is inspired by and improves PGM by 1) incorporating trainable weight projection radii for each layer and 2) developing a bi-level optimization algorithm to learn them." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 304, + 617, + 547, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 617, + 547, + 715 + ], + "spans": [ + { + "bbox": [ + 304, + 617, + 547, + 715 + ], + "type": "text", + "content": "Fine-tuning to Improve OOD Generalization. As the size of the target dataset increases and better architectures are developed, the benefit from pre-training on the target ID performance diminishes [13]. However, the power of pre-training goes beyond boosting ID performance. A recent work [40] finds that using pre-trained models can greatly improve robustness on OOD datasets and uncertainty-related tasks such as confidence calibration [10]" + } + ] + } + ], + "index": 11 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "spans": [ + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "text", + "content": "1For example, for a linear layer " + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "inline_equation", + "content": "y = \\mathbf{W}x + \\mathbf{b}" + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "text", + "content": ", we need to use separate distance constraints for " + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "inline_equation", + "content": "\\mathbf{W}" + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "inline_equation", + "content": "\\mathbf{b}" + }, + { + "bbox": [ + 46, + 693, + 287, + 712 + ], + "type": "text", + "content": "." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7837" + } + ] + } + ], + "index": 13 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 1 + }, + { + "para_blocks": [ + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "spans": [ + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "text", + "content": "and OOD detection [5]. Moreover, the fine-tuning strategy used also plays an important role in improving OOD generalization. LP-FT [21] shows that simultaneously fine-tuning the last linear layer and the feature backbone can distort pretrained features and thus decreases OOD generalization. A simple strategy of linear probing, i.e., training only the classifier layer, followed by fine-tuning the entire network can greatly mitigate this distortion and improve OOD generalization. WISE [41] demonstrates impressive OOD generalization gains by linearly interpolating " + }, + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 46, + 72, + 289, + 252 + ], + "type": "text", + "content": ". However, this strategy only applies to image-text pre-trained models with zero-shot classifiers such as CLIP [28] because WISE requires the model to have linear connectivity. In most cases, linear interpolation between two models results in no better performance than random initialization [7]." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 47, + 263, + 103, + 276 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 263, + 103, + 276 + ], + "spans": [ + { + "bbox": [ + 47, + 263, + 103, + 276 + ], + "type": "text", + "content": "3. Method" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 46, + 284, + 289, + 429 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 284, + 289, + 429 + ], + "spans": [ + { + "bbox": [ + 46, + 284, + 289, + 429 + ], + "type": "text", + "content": "In the introduction, we motivated the benefit of explicitly maintaining distance constraints between a pre-trained model and a fine-tuned model [9, 44]. However, it is not clear how to search the space of hyper-parameters (distance constraints) especially if we want to do this per layer as the search space grows combinatorially with the number of layers. To this end, we pose the search as a bi-level constrained optimization problem in Sec. 3.1 and introduce closed-form projection in Sec. 3.2. Then we present the proposed TPGM algorithm in Sec. 3.3. Finally, we theoretically show that the bi-level optimization design is the key for TPGM to learn different constraints for each layer in Sec. 3.4." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 47, + 437, + 287, + 449 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 437, + 287, + 449 + ], + "spans": [ + { + "bbox": [ + 47, + 437, + 287, + 449 + ], + "type": "text", + "content": "3.1. Fine-tuning as a Bi-level Constrained Problem" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "spans": [ + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "text", + "content": "Machine learning algorithms usually tune hyperparameters, e.g., learning rate, weight decay, etc., on a validation split. Mathematically, this procedure is equivalent to a bi-level minimization problem. Let " + }, + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "inline_equation", + "content": "(x,y)" + }, + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "text", + "content": " denote a pair of input data and " + }, + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "inline_equation", + "content": "\\mathcal{L}(\\cdot)" + }, + { + "bbox": [ + 46, + 456, + 287, + 529 + ], + "type": "text", + "content": " denote the task loss function. The minimization problem can be written as" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 62, + 539, + 287, + 559 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 62, + 539, + 287, + 559 + ], + "spans": [ + { + "bbox": [ + 62, + 539, + 287, + 559 + ], + "type": "interline_equation", + "content": "\\min _ {\\lambda \\mid (x, y) \\in \\mathcal {D} _ {v a l}} \\mathcal {L} (x, y; \\underset {\\theta_ {t} \\mid (x, y) \\in \\mathcal {D} _ {t r}} {\\arg \\min } \\mathcal {L} (x, y; \\theta_ {t}, \\lambda), \\lambda), \\tag {1}", + "image_path": "d89206bb62de9c6939f9e86006ed0fb70872b4b0a2decc3aaac20175837ab76c.jpg" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "spans": [ + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "inline_equation", + "content": "\\theta_{t}" + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "content": " denotes the trainable model weights and " + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "inline_equation", + "content": "\\lambda" + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "content": " denotes the hyper-parameters such as learning rate. " + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "inline_equation", + "content": "\\mathcal{D}_{tr}" + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "content": " is the set of training data and " + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "inline_equation", + "content": "\\mathcal{D}_{val}" + }, + { + "bbox": [ + 47, + 569, + 287, + 605 + ], + "type": "text", + "content": " is the set of validation data." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 46, + 606, + 288, + 714 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 606, + 288, + 714 + ], + "spans": [ + { + "bbox": [ + 46, + 606, + 288, + 714 + ], + "type": "text", + "content": "Now, we extend this formulation to fine-tune a pretrained model. Specifically, it has been shown that maintaining a close distance to the pre-trained model improves a model's generalization and robustness [16, 44]. A recent paper [9] formalizes the concept of maintaining distance as a constrained optimization problem, in which the distance between the new model and the pre-trained model is measured by matrix norms " + }, + { + "bbox": [ + 46, + 606, + 288, + 714 + ], + "type": "inline_equation", + "content": "\\| \\cdot \\|_*" + }, + { + "bbox": [ + 46, + 606, + 288, + 714 + ], + "type": "text", + "content": ". Mathematically, combined with Eq. 1, we further extend the constrained optimization" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 305, + 72, + 508, + 84 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 305, + 72, + 508, + 84 + ], + "spans": [ + { + "bbox": [ + 305, + 72, + 508, + 84 + ], + "type": "text", + "content": "to a bi-level constrained minimization problem as" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 317, + 92, + 545, + 130 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 317, + 92, + 545, + 130 + ], + "spans": [ + { + "bbox": [ + 317, + 92, + 545, + 130 + ], + "type": "interline_equation", + "content": "\\begin{array}{l} \\min _ {\\lambda , \\gamma | (x, y) \\in \\mathcal {D} _ {v a l}} \\mathcal {L} (x, y; \\underset {\\theta_ {t} | (x, y) \\in \\mathcal {D} _ {t r}} {\\arg \\min } \\mathcal {L} (x, y; \\theta_ {t}, \\lambda), \\lambda), \\tag {2} \\\\ \\begin{array}{c c} \\text {s . t .} & \\| \\theta_ {t} - \\theta_ {0} \\| _ {*} \\leq \\gamma , \\end{array} \\\\ \\end{array}", + "image_path": "baa862c46214eb57cfbbf48b25d4484767ca88416554ba9e63d58965f32be37a.jpg" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "spans": [ + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "inline_equation", + "content": "\\| \\theta_t - \\theta_0\\|_*" + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "content": " denotes a norm induced distance between the pre-trained model " + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "content": " and the new model " + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "content": ". Optimizing Eq. 2 enforces the model to stay within a distance " + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 304, + 137, + 547, + 186 + ], + "type": "text", + "content": " from the pre-trained model." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 305, + 192, + 459, + 205 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 305, + 192, + 459, + 205 + ], + "spans": [ + { + "bbox": [ + 305, + 192, + 459, + 205 + ], + "type": "text", + "content": "3.2. Projected Gradient Method" + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "spans": [ + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": "One method to optimize a constrained problem is projected gradient method (PGM) [18]. PGM projects the updated model weights to be within the constraint, i.e., " + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "inline_equation", + "content": "\\| \\theta_t - \\theta_0\\|_* \\leq \\gamma" + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": ". However, in general, most projection operations are optimization problems themselves with only a few exceptions having closed from solutions. One example is L2-norm projection " + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "inline_equation", + "content": "\\Pi_{l2}" + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": ". Projecting a matrix " + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "inline_equation", + "content": "\\theta_t" + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": " to " + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": " distance away, measured by L2 norm, from another matrix " + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 304, + 211, + 545, + 319 + ], + "type": "text", + "content": " is a closed form operation as shown in Eq. 3." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 311, + 326, + 545, + 360 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 311, + 326, + 545, + 360 + ], + "spans": [ + { + "bbox": [ + 311, + 326, + 545, + 360 + ], + "type": "interline_equation", + "content": "\\Pi_ {l 2} \\left(\\theta_ {0}, \\theta_ {t}, \\gamma\\right): \\tilde {\\theta} = \\theta_ {0} + \\frac {1}{\\max \\left(1 , \\frac {\\| \\theta_ {t} - \\theta_ {0} \\| _ {2}}{\\gamma}\\right)} \\left(\\theta_ {t} - \\theta_ {0}\\right) \\tag {3}", + "image_path": "60251748f35da6f8a7007d21840858ec7275b655db9105a20a576380a0959406.jpg" + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 365, + 545, + 425 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 365, + 545, + 425 + ], + "spans": [ + { + "bbox": [ + 304, + 365, + 545, + 425 + ], + "type": "text", + "content": "The prior work [9] uses the maximum absolute row sum (MARS) matrix norm because it has a closed form approximation that enables fast projection without optimization as well. The MARS approximate projection operator " + }, + { + "bbox": [ + 304, + 365, + 545, + 425 + ], + "type": "inline_equation", + "content": "\\Pi_{mars}" + }, + { + "bbox": [ + 304, + 365, + 545, + 425 + ], + "type": "text", + "content": " is defined in Eq. 4." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 309, + 431, + 545, + 476 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 309, + 431, + 545, + 476 + ], + "spans": [ + { + "bbox": [ + 309, + 431, + 545, + 476 + ], + "type": "interline_equation", + "content": "\\Pi_ {m a r s} \\left(\\theta_ {0}, \\theta_ {t}, \\gamma\\right): \\tilde {\\theta} = \\theta_ {0} + \\frac {1}{\\max \\left(1 , \\frac {\\| \\theta_ {t} - \\theta_ {0} \\| _ {\\infty}}{\\gamma}\\right)} \\left(\\theta_ {t} - \\theta_ {0}\\right) \\tag {4}", + "image_path": "b0daf6dd48d30749a60fa70f664e4ef93186717fe4067fa0a518e1f1ae36322b.jpg" + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "spans": [ + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\| \\cdot \\|_{\\infty}" + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "text", + "content": " denotes the MARS matrix norm, " + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\| A \\|_{\\infty} = \\max_j \\sum_{i=1} |A_{j,i}|" + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "text", + "content": ". Even though we use closed-form projection to avoid additional computation, the projection radius " + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "text", + "content": " needs to be pre-determined. Searching for a single weight projection parameter for all layers is already challenging because the scale of " + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 304, + 483, + 545, + 617 + ], + "type": "text", + "content": " is unknown let alone tailoring a weight projection radius to each layer. In this paper, we do not investigate specific properties of projections, which are orthogonal to our contributions. Therefore, we will benchmark both projections and report the one with better results and leave the comparison to Appendix." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 306, + 623, + 545, + 635 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 623, + 545, + 635 + ], + "spans": [ + { + "bbox": [ + 306, + 623, + 545, + 635 + ], + "type": "text", + "content": "3.3. Trainable Projected Gradient Method (TPGM)" + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 304, + 642, + 545, + 714 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 642, + 545, + 714 + ], + "spans": [ + { + "bbox": [ + 304, + 642, + 545, + 714 + ], + "type": "text", + "content": "Inspired by the projected gradient method, we propose a trainable approach to solve the bi-level constrained problem in Eq. 2 by integrating the projection operator in Eq. 3 or Eq. 4 into the forward pass of a model, through which the weight projection radii " + }, + { + "bbox": [ + 304, + 642, + 545, + 714 + ], + "type": "inline_equation", + "content": "\\gamma" + }, + { + "bbox": [ + 304, + 642, + 545, + 714 + ], + "type": "text", + "content": " can be learned through backpropagation. Specifically, the algorithm consists of three" + } + ] + } + ], + "index": 18 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7838" + } + ] + } + ], + "index": 19 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 2 + }, + { + "para_blocks": [ + { + "type": "code", + "bbox": [ + 60, + 89, + 272, + 209 + ], + "blocks": [ + { + "bbox": [ + 54, + 75, + 141, + 87 + ], + "lines": [ + { + "bbox": [ + 54, + 75, + 141, + 87 + ], + "spans": [ + { + "bbox": [ + 54, + 75, + 141, + 87 + ], + "type": "text", + "content": "Algorithm 1: TPGM" + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "code_caption" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "lines": [ + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "spans": [ + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": "Data: " + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "inline_equation", + "content": "\\mathcal{D}_{tr},\\mathcal{D}_{val}" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": " \nResult: " + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}_{t + 1}" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": " \nInitialize " + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}_0 = \\theta_0,\\gamma_0 = \\epsilon" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": " \nfor " + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "inline_equation", + "content": "t = \\{0,\\dots ,T - 1\\}" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": " do " + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "inline_equation", + "content": "\\begin{array}{rl} & {\\theta_{t + 1} = \\theta_t - \\eta_t\\nabla_\\theta \\mathcal{L}(x,y;\\tilde{\\theta}_t)\\quad x,y\\in \\mathcal{D}_{tr}}\\\\ & {\\mathrm{if~}t\\bmod f_{proj} == 0\\mathrm{then}}\\\\ & {\\gamma_{t + 1} = \\mathrm{ProjectionUpdate}(\\mathcal{D}_{val},\\theta_0,\\theta_{t + 1},\\gamma_t)}\\\\ & {\\tilde{\\theta}_{t + 1} = \\Pi (\\theta_0,\\theta_{t + 1},\\gamma_{t + 1})} \\end{array}" + }, + { + "bbox": [ + 60, + 89, + 272, + 209 + ], + "type": "text", + "content": " \nend" + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "code_body" + } + ], + "index": 1, + "sub_type": "algorithm" + }, + { + "type": "code", + "bbox": [ + 59, + 246, + 248, + 316 + ], + "blocks": [ + { + "bbox": [ + 54, + 232, + 183, + 243 + ], + "lines": [ + { + "bbox": [ + 54, + 232, + 183, + 243 + ], + "spans": [ + { + "bbox": [ + 54, + 232, + 183, + 243 + ], + "type": "text", + "content": "Algorithm 2: ProjectionUpdate" + } + ] + } + ], + "index": 2, + "angle": 0, + "type": "code_caption" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "lines": [ + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "spans": [ + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "text", + "content": "Data: " + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "\\mathcal{D}_{val}" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "text", + "content": " \nResult: " + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "\\gamma_{t+1}" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "text", + "content": " \nfor " + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "\\tau = \\{0, \\dots, T_{proj} - 1\\}" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "text", + "content": " do \n" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta} = \\Pi(\\theta_0, \\theta_{t+1}, \\gamma_\\tau)" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "\\gamma_{\\tau+1} = \\gamma_\\tau - \\zeta \\nabla_\\gamma \\mathcal{L}(x, y; \\tilde{\\theta})" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "inline_equation", + "content": "x, y \\in \\mathcal{D}_{val}" + }, + { + "bbox": [ + 59, + 246, + 248, + 316 + ], + "type": "text", + "content": " \nend" + } + ] + } + ], + "index": 3, + "angle": 0, + "type": "code_body" + } + ], + "index": 3, + "sub_type": "algorithm" + }, + { + "bbox": [ + 46, + 346, + 287, + 380 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 346, + 287, + 380 + ], + "spans": [ + { + "bbox": [ + 46, + 346, + 287, + 380 + ], + "type": "text", + "content": "functions: model update, projection update, and projection. A summary of TPGM is presented in Alg. 1 and details of the projection update function are in Alg. 2." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "spans": [ + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": "Model Update. TPGM first takes an unconstrained gradient descent step. Let " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "\\theta_{t + 1}" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " denote the updated model parameters at the gradient descent step " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "t" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " for " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "t\\geq 0" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " where " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " denotes the pre-trained initialization. This update is calculated on the loss function " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "\\mathcal{L}(x,y;\\theta_t)" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " where " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "(x,y)" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": " are sampled training data, i.e., " + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "inline_equation", + "content": "(x,y)\\in \\mathcal{D}_{tr}" + }, + { + "bbox": [ + 46, + 381, + 287, + 489 + ], + "type": "text", + "content": ". This corresponds to a regular gradient descent step in the conventional setting and the inner minimization in Eq. 2. For example, if vanilla SGD is used in this step, then," + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 73, + 499, + 259, + 512 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 73, + 499, + 259, + 512 + ], + "spans": [ + { + "bbox": [ + 73, + 499, + 259, + 512 + ], + "type": "interline_equation", + "content": "\\theta_ {t + 1} = \\theta_ {t} - \\eta_ {t} \\nabla_ {\\theta} \\mathcal {L} (x, y; \\theta_ {t}), \\quad (x, y) \\in \\mathcal {D} _ {t r}.", + "image_path": "8dc11c62220b31565798aeaaf725cbed4067239f42eb1d909902e5ebe567fc7d.jpg" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 47, + 521, + 286, + 533 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 521, + 286, + 533 + ], + "spans": [ + { + "bbox": [ + 47, + 521, + 286, + 533 + ], + "type": "text", + "content": "Any other optimizers, e.g., Adam [20], can be used instead." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "spans": [ + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": "Projection Update. The projection update function optimizes the weight projection parameters " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\gamma_{t}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " iteratively. As shown in Alg. 2, the optimization loops for " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "T_{proj}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " steps. In Alg. 2, we use SGD as an example for clarity. Any other optimizer can be used. Specifically, using " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\theta_{t + 1}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " and the closed form projection operation in Eq. 3 (or Eq. 4), we construct a projected model " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " with a trainable projection parameter " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\gamma_{t}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " for " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "t\\geq 0" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " for each layer, where " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\gamma_0" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " is initialized to a small value " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": ". Then, we optimize the projection parameters using the loss function " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\mathcal{L}(x,y;\\gamma_t)" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " where " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "(x,y)" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " are sampled validation data, i.e., " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "(x,y)\\in D_{val}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": ". Crucially, in this step, only the weight projection parameters " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\gamma_{t}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " are updated while the updated model " + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "inline_equation", + "content": "\\theta_{t + 1}" + }, + { + "bbox": [ + 46, + 534, + 287, + 713 + ], + "type": "text", + "content": " remains frozen. In other words, no gradients of the model are calculated on the validation data. This is important to avoid contamination of the vali" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 305, + 72, + 545, + 95 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 305, + 72, + 545, + 95 + ], + "spans": [ + { + "bbox": [ + 305, + 72, + 545, + 95 + ], + "type": "text", + "content": "dation data. The projection update function corresponds to the outer minimization of the constrained problem in Eq. 2." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "spans": [ + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": "Projection. Finally, after a new set of projection parameters " + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "inline_equation", + "content": "\\gamma_{t}" + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": " is updated, we apply the learned projection radii to the updated model " + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "inline_equation", + "content": "\\theta_{t + 1}" + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": " using Eq. 3 (or Eq. 4). This amounts to enforcing the constraint " + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "inline_equation", + "content": "\\| \\theta -\\theta_0\\|_*\\leq \\gamma" + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": " in Eq 2. The projection update and projection functions can be called frequently controlled by a hyperparameter " + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "inline_equation", + "content": "(f_{proj}" + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": " in Alg. 1). We will show that for certain pre-trained models, it is sufficient to only call these two functions once at the end of the training, i.e., when " + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "inline_equation", + "content": "f_{proj} = T - 1" + }, + { + "bbox": [ + 304, + 96, + 545, + 263 + ], + "type": "text", + "content": " (Sec. 4.2). Moreover, we found that in a few cases, TPGM could lead to under-fitting because of its iterative nature. However, the problem can be easily mitigated with total variation smoothing [1,3]. Since we only observed this in one setting in our experiments, we defer the discussion to Appendix 5.3." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 304, + 263, + 545, + 384 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 263, + 545, + 384 + ], + "spans": [ + { + "bbox": [ + 304, + 263, + 545, + 384 + ], + "type": "text", + "content": "We summarize TPGM in Alg. 1. Intuitively, TPGM maintains a set of weight projection parameters for each layer of a neural network and updates them. The projection parameters control how much \"freedom\" each layer has to grow. As we will observe later, when fine-tuning a model, layers close to the input generally require smaller changes than layers close to the output. This property helps preserve generalization capabilities obtained by the pre-trained model. TPGM inevitably adds some computation overhead. We provide additional discussion on it in Appendix 5.9." + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 306, + 389, + 477, + 403 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 389, + 477, + 403 + ], + "spans": [ + { + "bbox": [ + 306, + 389, + 477, + 403 + ], + "type": "text", + "content": "3.4. Bi-level Optimization is the Key" + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 408, + 545, + 456 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 408, + 545, + 456 + ], + "spans": [ + { + "bbox": [ + 304, + 408, + 545, + 456 + ], + "type": "text", + "content": "Following common strategy in studying transfer learning [6,36,41-43], we theoretically study TPGM using linear models and explain why it is critical to optimize the bi-level problem in Eq. 2." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "spans": [ + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": "Problem Setup. Let " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "x \\in \\mathbb{R}^d" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": " denote an ID data and the corresponding label " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "y" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": " is generated by a ground truth linear model " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "\\theta_* \\in \\mathbb{R}^d" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": ", i.e., " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "y = \\theta_*^T x" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": ". To construct the training set, we sample " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "n" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": " training data, where " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "n < d" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": ", and stack the sampled data into a data matrix " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "\\mathbf{X}_{tr} \\in \\mathbb{R}^{d \\times n}" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": ". Accordingly, the labels form a vector " + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "inline_equation", + "content": "\\mathbf{Y}_{tr} = \\mathbf{X}_{tr}^T\\theta_* \\in \\mathbb{R}^n" + }, + { + "bbox": [ + 304, + 456, + 545, + 540 + ], + "type": "text", + "content": ". The training goal is to minimize the empirical loss." + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 355, + 546, + 545, + 561 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 355, + 546, + 545, + 561 + ], + "spans": [ + { + "bbox": [ + 355, + 546, + 545, + 561 + ], + "type": "interline_equation", + "content": "\\mathcal {L} \\left(\\mathbf {X} _ {t r}, \\mathbf {Y} _ {t r}; \\theta\\right) = \\left\\| \\mathbf {X} _ {t r} ^ {T} \\theta - \\mathbf {Y} _ {t r} \\right\\| _ {2} \\tag {5}", + "image_path": "53f3163df5758c1fcbc42dd0e414505f5b93084105cd564cc6db563d7db22883.jpg" + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 567, + 545, + 614 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 567, + 545, + 614 + ], + "spans": [ + { + "bbox": [ + 304, + 567, + 545, + 614 + ], + "type": "text", + "content": "Note that this forms an over-parameterized linear system, i.e., there are more parameters than equations, because " + }, + { + "bbox": [ + 304, + 567, + 545, + 614 + ], + "type": "inline_equation", + "content": "n < d" + }, + { + "bbox": [ + 304, + 567, + 545, + 614 + ], + "type": "text", + "content": ". This is similar to how modern neural networks are over-parameterized with respect to the data." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 304, + 615, + 545, + 663 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 615, + 545, + 663 + ], + "spans": [ + { + "bbox": [ + 304, + 615, + 545, + 663 + ], + "type": "text", + "content": "Complementary Decomposition using SVD. For the analysis, we make an independence assumption on the data matrix " + }, + { + "bbox": [ + 304, + 615, + 545, + 663 + ], + "type": "inline_equation", + "content": "\\mathbf{X}_{tr}" + }, + { + "bbox": [ + 304, + 615, + 545, + 663 + ], + "type": "text", + "content": ". This assumption exists for notation simplicity and can be relaxed easily." + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "spans": [ + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "text", + "content": "Assumption 1. Let the " + }, + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "inline_equation", + "content": "n" + }, + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "text", + "content": " training data be linearly independent. The following SVD exists for the data matrix " + }, + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "inline_equation", + "content": "\\mathbf{X}_{tr}" + }, + { + "bbox": [ + 304, + 670, + 545, + 693 + ], + "type": "text", + "content": "." + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 313, + 700, + 537, + 713 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 313, + 700, + 537, + 713 + ], + "spans": [ + { + "bbox": [ + 313, + 700, + 537, + 713 + ], + "type": "interline_equation", + "content": "\\mathbf {X} _ {t r} = \\mathbf {U} \\boldsymbol {\\Sigma} \\mathbf {V} ^ {T}, \\quad \\mathbf {U} \\in \\mathbb {R} ^ {d \\times n}, \\boldsymbol {\\Sigma} \\in \\mathbb {R} ^ {n \\times n}, \\mathbf {V} \\in \\mathbb {R} ^ {n \\times n}.", + "image_path": "b0311b4668549bc7a1682c9ece47096e7108f7f62458304dd743c7948b147346.jpg" + } + ] + } + ], + "index": 19 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7839" + } + ] + } + ], + "index": 20 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 3 + }, + { + "para_blocks": [ + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "spans": [ + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": "Consequently, we can decompose any vector " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "x \\in \\mathbb{R}^d" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": " into two components, " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "x = \\mathbf{U}\\tau + \\mathbf{U}_{\\perp}\\tau_{\\perp}" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": ", where " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "\\mathbf{U}" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": " is the basis for the span of training samples, " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "\\mathbf{U}_{\\perp} \\in \\mathbb{R}^{d \\times (d - n)}" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": " is the basis for the complementary subspace, and " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "\\tau \\in \\mathbb{R}^n" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": ", " + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "inline_equation", + "content": "\\tau_{\\perp} \\in \\mathbb{R}^{d - n}" + }, + { + "bbox": [ + 47, + 72, + 287, + 156 + ], + "type": "text", + "content": " are the corresponding coordinates. There are infinitely many solutions to Eq. 5 because this is an overparameterized system." + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "spans": [ + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "content": "Definition 1. We denote a projected model as " + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta} = \\theta_0 + \\alpha (\\theta -\\theta_0)" + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "content": " (obtained using Eq. 3 or Eq. 4), where " + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "inline_equation", + "content": "\\theta" + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "content": " is one minimizer of Eq. 5, " + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "inline_equation", + "content": "\\theta_0" + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "content": " is the pre-trained model and " + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "inline_equation", + "content": "0\\leq \\alpha \\leq 1" + }, + { + "bbox": [ + 47, + 163, + 286, + 212 + ], + "type": "text", + "content": " is the projection ratio." + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "spans": [ + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "text", + "content": "To quantify the effects of projection " + }, + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "text", + "content": ", we can look at the average performance of the projected model " + }, + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}" + }, + { + "bbox": [ + 47, + 219, + 286, + 267 + ], + "type": "text", + "content": " on test data. Consequently, we investigate the expected loss of the projected model over the entire data space." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 98, + 274, + 286, + 297 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 98, + 274, + 286, + 297 + ], + "spans": [ + { + "bbox": [ + 98, + 274, + 286, + 297 + ], + "type": "interline_equation", + "content": "\\mathbb {E} [ \\mathcal {L} (x, y; \\tilde {\\theta}) ] = \\mathbb {E} \\left[ \\left\\| \\tilde {\\theta} ^ {T} x - y \\right\\| _ {2} \\right] \\tag {6}", + "image_path": "b7f7d83abfcf595cded8e3ed031cba422252c37ab3f5cc020a304ef8f6f944d2.jpg" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 47, + 303, + 286, + 327 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 303, + 286, + 327 + ], + "spans": [ + { + "bbox": [ + 47, + 303, + 286, + 327 + ], + "type": "text", + "content": "We provide the following theorem to shed light on how projection affects the expected loss and what it depends on." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 47, + 334, + 286, + 358 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 334, + 286, + 358 + ], + "spans": [ + { + "bbox": [ + 47, + 334, + 286, + 358 + ], + "type": "text", + "content": "Theorem 1. Let Assumption 1 hold, the expected loss of " + }, + { + "bbox": [ + 47, + 334, + 286, + 358 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}" + }, + { + "bbox": [ + 47, + 334, + 286, + 358 + ], + "type": "text", + "content": " in Eq. 6 is upper bounded as the following," + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 53, + 365, + 286, + 410 + ], + "type": "interline_equation", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 365, + 286, + 410 + ], + "spans": [ + { + "bbox": [ + 53, + 365, + 286, + 410 + ], + "type": "interline_equation", + "content": "\\mathbb {E} \\left[ \\left\\| \\tilde {\\theta} ^ {T} x - y \\right\\| _ {2} \\right] \\leq \\underbrace {(1 - \\alpha) \\epsilon \\tau} _ {i n - s p a n} + \\underbrace {\\left(\\epsilon + \\alpha \\| \\theta - \\theta_ {0} \\| _ {2}\\right) \\tau_ {\\perp}} _ {o u t - s p a n}, \\tag {7}", + "image_path": "3536087ec73a27730f5251d6e28e52a62ed79d2ac9a9f326806fd0af91bf7711.jpg" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "spans": [ + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "text", + "content": "where " + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "inline_equation", + "content": "\\epsilon = \\| \\theta_0 - \\theta_*\\| _2" + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "inline_equation", + "content": "\\tau \\doteq \\mathbb{E}[\\| \\tau \\| _2]" + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "inline_equation", + "content": "\\tau_{\\perp}\\doteq \\mathbb{E}[\\| \\tau_{\\perp}\\| _2]" + }, + { + "bbox": [ + 47, + 419, + 285, + 444 + ], + "type": "text", + "content": " A complete proof is provided in Appendix 5.2." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "spans": [ + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": "The upper bound in Thm. 1 has two components, risk due to components in the training data span (in-span) and risk due to components in the complementary subspace (out-span). To minimize the expected loss, one will expect " + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": " to be dependent on the value of " + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": ". Recall that the quantity " + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": " is the distance between the pre-trained model and the ground truth model and can be viewed as a measure of how \"good\" the pre-trained model is. Therefore, we expect two types of behaviors from " + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": " depending on " + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 47, + 451, + 286, + 559 + ], + "type": "text", + "content": ":" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 59, + 566, + 286, + 622 + ], + "type": "list", + "angle": 0, + "index": 11, + "blocks": [ + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "spans": [ + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "text", + "content": "- When " + }, + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "text", + "content": " is small, " + }, + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 59, + 566, + 286, + 590 + ], + "type": "text", + "content": " needs to be smaller to minimize the second component, meaning stronger projection." + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "spans": [ + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "text", + "content": "- When " + }, + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "text", + "content": " is large, " + }, + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 59, + 597, + 286, + 622 + ], + "type": "text", + "content": " needs to be larger to minimize the first component, meaning weaker projection." + } + ] + } + ], + "index": 10 + } + ], + "sub_type": "text" + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "spans": [ + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "text", + "content": "The theorem indicates that, if we optimize the projected model " + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "inline_equation", + "content": "\\tilde{\\theta}" + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "text", + "content": " on a separate dataset sampled independently from the training data, the projection ratio " + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "inline_equation", + "content": "\\alpha" + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "text", + "content": " will seek to balance between fitting the training data (in-span) and generalizing to new data (out-span). For example, when " + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 47, + 629, + 286, + 713 + ], + "type": "text", + "content": " is small, i.e., the pre-trained model is close to the optimal model, the formulation encourages stronger projection." + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 304, + 72, + 545, + 204 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 72, + 545, + 204 + ], + "spans": [ + { + "bbox": [ + 304, + 72, + 545, + 204 + ], + "type": "text", + "content": "Furthermore, as prior works have found that lower layers tend to learn more general features while higher layers specialize to a specific dataset, " + }, + { + "bbox": [ + 304, + 72, + 545, + 204 + ], + "type": "inline_equation", + "content": "\\epsilon" + }, + { + "bbox": [ + 304, + 72, + 545, + 204 + ], + "type": "text", + "content": " is likely to be smaller for the lower layers and larger for higher layers because pre-trained models likely have learned very good low-level general features [26, 29, 41, 45]. This offers one explanation of why TPGM automatically learns different constraints for each layer. Therefore, we hypothesize that optimizing the projection radii on a dataset sampled separately from the training data, e.g., the validation dataset, is essential to learning different constraints for each layer." + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 306, + 213, + 386, + 227 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 213, + 386, + 227 + ], + "spans": [ + { + "bbox": [ + 306, + 213, + 386, + 227 + ], + "type": "text", + "content": "4. Experiments" + } + ] + } + ], + "index": 14 + }, + { + "bbox": [ + 304, + 234, + 545, + 329 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 234, + 545, + 329 + ], + "spans": [ + { + "bbox": [ + 304, + 234, + 545, + 329 + ], + "type": "text", + "content": "Overview. To validate TPGM, we conduct experiments on large-scale datasets using different architectures. The experiments are split into two sections depending on the specific architecture used. In Sec. 4.1, we use ResNet [14] with a CLIP pre-trained ResNet50 [28] and an ImageNet pretrained MOCO-V3 ResNet50 [2] as the pre-trained models. In Sec. 4.2, we use Vision Transformers [37] with a CLIP pre-trained ViT-B model [28]." + } + ] + } + ], + "index": 15 + }, + { + "bbox": [ + 304, + 330, + 545, + 460 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 330, + 545, + 460 + ], + "spans": [ + { + "bbox": [ + 304, + 330, + 545, + 460 + ], + "type": "text", + "content": "Datasets. For the ResNet experiments, we use DomainNet [27] (0.6M images over 345 classes) as the benchmark. DomainNet has five domains: real, sketch, painting, infograph, and clipart. We use the real domain as the ID finetuning domain (with held-out test data to test ID performance) and the rest as the OOD domains. For the Transformer experiments, we use ImageNet-1K [4] as the finetuning dataset. For the ID test dataset, we add ImageNet-V2 [30] in addition to ImageNet-1K. For the OOD test datasets, we use ImageNet-A [17], ImageNet-R [15], and ImageNet-S [38]. No OOD data are used during training." + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 306, + 468, + 487, + 480 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 468, + 487, + 480 + ], + "spans": [ + { + "bbox": [ + 306, + 468, + 487, + 480 + ], + "type": "text", + "content": "4.1. Fine-Tuning a Pre-trained ResNet" + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "spans": [ + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "text", + "content": "In this section, we compare TPGM to several existing methods using a CLIP pre-trained ResNet50 [28] and ImageNet pre-trained MOCO-V3 ResNet50 [2] as initialization. Specifically for TPGM, we use " + }, + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "inline_equation", + "content": "f_{proj} = 1" + }, + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "text", + "content": ", " + }, + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "inline_equation", + "content": "T_{proj} = 1" + }, + { + "bbox": [ + 304, + 486, + 545, + 713 + ], + "type": "text", + "content": ", meaning that projection update and projection are activated at every gradient descent step (Alg. 1). We also use the MARS projection in Eq. 4 because we found that MARS projection performs better than L2 projection in this setting (Appendix 5.6). Moreover, we do not include WISE [41] in this comparison because we found that CLIP pre-trained ResNet50 has poor linear connectivity, i.e., linear interpolation results in drastic degradation of performance (Appendix 5.7). Therefore, we do not use any zero-shot classifiers for initializing the last linear layer (See sec. 4.2 for a detailed description of zero-shot classifiers). The recipe for training ResNet is relatively simple. We use the Adam optimizer [20] with default settings and a batch size of 256. Models are fine-tuned for 50 epochs with a cosine learning rate schedule. The same training recipe is used for all experi" + } + ] + } + ], + "index": 18 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7840" + } + ] + } + ], + "index": 19 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 4 + }, + { + "para_blocks": [ + { + "type": "table", + "bbox": [ + 85, + 102, + 507, + 200 + ], + "blocks": [ + { + "bbox": [ + 46, + 70, + 547, + 94 + ], + "lines": [ + { + "bbox": [ + 46, + 70, + 547, + 94 + ], + "spans": [ + { + "bbox": [ + 46, + 70, + 547, + 94 + ], + "type": "text", + "content": "Table 1. DomainNet Results using CLIP pre-trained ResNet50 with " + }, + { + "bbox": [ + 46, + 70, + 547, + 94 + ], + "type": "inline_equation", + "content": "100\\%" + }, + { + "bbox": [ + 46, + 70, + 547, + 94 + ], + "type": "text", + "content": " Real Data. TPGM improves OOD performance significantly even when a zero-shot classifier is not available." + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 85, + 102, + 507, + 200 + ], + "lines": [ + { + "bbox": [ + 85, + 102, + 507, + 200 + ], + "spans": [ + { + "bbox": [ + 85, + 102, + 507, + 200 + ], + "type": "table", + "html": "
ID RealOODStatistics
SketchPaintingInfographClipartOOD Avg.ID Δ (%)OOD Δ (%)
Vanilla FT80.93 (0.08)31.81 (0.06)41.02 (0.10)20.29 (0.08)43.59 (0.15)34.180.000.00
LP52.56 (0.09)20.05 (0.21)24.92 (2.49)19.18 (0.46)21.15 (0.18)21.33-35.05-37.60
PF [19]78.27 (0.11)36.77 (0.32)42.13 (0.35)24.71 (0.18)43.31 (0.53)36.73-3.297.46
L2-SP [44]82.07 (0.09)36.67 (0.11)45.62 (0.35)22.97 (0.42)47.78 (0.30)38.261.4011.94
MARS-SP [9]77.19 (0.63)25.33 (1.07)33.43 (2.06)14.81 (0.43)39.20 (0.74)28.19-4.62-17.53
LP-FT [21]80.82 (0.95)34.85 (1.93)44.03 (0.05)22.23 (2.01)46.13 (2.34)36.81-0.147.69
TPGM83.64 (0.01)38.78 (0.42)43.11 (0.25)28.70 (0.31)48.01 (0.25)39.653.3416.01
", + "image_path": "41c8c698a40a45b56bee7766009e684fa9d9be52fe09f8f3ce2458286e4febd1.jpg" + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "table_body" + } + ], + "index": 1 + }, + { + "type": "table", + "bbox": [ + 85, + 241, + 506, + 340 + ], + "blocks": [ + { + "bbox": [ + 46, + 209, + 546, + 234 + ], + "lines": [ + { + "bbox": [ + 46, + 209, + 546, + 234 + ], + "spans": [ + { + "bbox": [ + 46, + 209, + 546, + 234 + ], + "type": "text", + "content": "Table 2. DomainNet Results using MOCO-V3 pre-trained ResNet50 Results with 100% Real Data. TPGM improves OOD generalization using a self-supervised pre-trained model while improving ID performance." + } + ] + } + ], + "index": 2, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 85, + 241, + 506, + 340 + ], + "lines": [ + { + "bbox": [ + 85, + 241, + 506, + 340 + ], + "spans": [ + { + "bbox": [ + 85, + 241, + 506, + 340 + ], + "type": "table", + "html": "
ID RealOODStatistics
SketchPaintingInfographClipartOOD Avg.ID Δ (%)OOD Δ (%)
Vanilla FT81.99 (0.03)31.52 (0.33)42.89 (0.53)18.51 (0.28)44.98 (0.24)34.470.000.00
LP73.01 (0.03)24.10 (0.23)39.56 (0.15)12.27 (0.02)30.38 (0.08)26.58-10.96-22.90
PF [19]78.27 (0.03)27.72 (0.07)39.74 (0.12)15.56 (0.08)38.18 (0.12)30.30-4.55-12.11
L2-SP [44]81.51 (0.02)34.91 (0.22)45.76 (0.16)18.97 (0.11)45.29 (0.18)36.23-0.595.09
MARS-SP [9]81.89 (0.01)34.44 (2.54)45.05 (1.91)19.97 (1.48)46.36 (1.29)36.45-0.135.74
LP-FT [21]82.92 (0.01)34.50 (0.22)45.42 (0.31)20.12 (0.43)47.11 (0.27)36.791.136.72
TPGM82.66 (0.13)35.35 (0.33)46.20 (0.20)20.13 (0.12)45.75 (0.12)36.860.826.91
", + "image_path": "9815cf97dd741243a968336fcd4860ead9649a6eb4f5b5e355a0d89330035f29.jpg" + } + ] + } + ], + "index": 3, + "angle": 0, + "type": "table_body" + } + ], + "index": 3 + }, + { + "bbox": [ + 46, + 358, + 287, + 382 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 358, + 287, + 382 + ], + "spans": [ + { + "bbox": [ + 46, + 358, + 287, + 382 + ], + "type": "text", + "content": "iments unless otherwise specified. Implementation details are provided in Appendix 5.4." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 46, + 384, + 288, + 587 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 384, + 288, + 587 + ], + "spans": [ + { + "bbox": [ + 46, + 384, + 288, + 587 + ], + "type": "text", + "content": "TPGM improves OOD robustness without sacrificing ID performance. We first present the main results on DomainNet using CLIP pre-trained ResNe50. As shown in Tab. 1, we observe that both L2-SP and LP-FT bring significant improvements to OOD generalization with respect to vanilla FT while matching or surpassing its ID accuracy. Nevertheless, TPGM brings the most OOD improvement while also surpassing vanilla FT on ID accuracy. We also report results using MOCO-V3 in Tab. 2. MOCO-V3 is pretrained on ImageNet-1K (1.2M) consisting of mainly real images, a much smaller and less diverse pre-training data set than CLIP's. Therefore, we see worse OOD generalization results from all methods, compared to using CLIP pre-trained models (Tab. 1). This indicates that the size and diversity of the pre-training dataset have a huge impact on generalization. Nevertheless, TPGM yields the best OOD performance while matching the best ID performance." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 46, + 588, + 288, + 673 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 588, + 288, + 673 + ], + "spans": [ + { + "bbox": [ + 46, + 588, + 288, + 673 + ], + "type": "text", + "content": "TPGM adjusts to the size of training data. As an automatic regularization method, TPGM also needs to adjust to different regularization strengths according to the size of the training set. TPGM can avoid over-fitting to a small fine-tuning dataset through the outer minimization loop of the projection parameters on validation data (Eq. 2). In this section, we additionally present results when we re" + } + ] + } + ], + "index": 6 + }, + { + "type": "image", + "bbox": [ + 335, + 360, + 522, + 444 + ], + "blocks": [ + { + "bbox": [ + 335, + 360, + 522, + 444 + ], + "lines": [ + { + "bbox": [ + 335, + 360, + 522, + 444 + ], + "spans": [ + { + "bbox": [ + 335, + 360, + 522, + 444 + ], + "type": "image", + "image_path": "458ab495c8ebfba1216d793fb83e8a8746a9f5c60958ca72d4eb4bdde1e99057.jpg" + } + ] + } + ], + "index": 7, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 305, + 460, + 547, + 506 + ], + "lines": [ + { + "bbox": [ + 305, + 460, + 547, + 506 + ], + "spans": [ + { + "bbox": [ + 305, + 460, + 547, + 506 + ], + "type": "text", + "content": "Figure 2. Average distance between the fine-tuned model and a CLIP pre-trained ResNet50 for each Residual block using TPGM. Under the distance constraints imposed by TPGM, most of the model changes are in the last adaptive pooling layer." + } + ] + } + ], + "index": 8, + "angle": 0, + "type": "image_caption" + } + ], + "index": 7 + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "spans": [ + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": "duce the DomainNet-Real data to " + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "inline_equation", + "content": "10\\%" + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": " of its original size. We follow a similar strategy as in the " + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "inline_equation", + "content": "100\\%" + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": " experiments and sweep different learning rates (for competing methods we sweep their hyperparameters). All models are trained for 150 epochs. In Tab. 3, we observe significant degradation in ID performance across all methods except for PF and TPGM. PF only trains the Batch-norm layers and therefore is less prone to over-fitting. TPGM achieves an even higher ID performance because it learns small projection radii, which project the fine-tuned model closer to the pre-trained model. To see it, we visualize the average distance between the fine-tuned model and the pre-trained model for each residual block using TPGM for both " + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "inline_equation", + "content": "100\\%" + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "inline_equation", + "content": "10\\%" + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": " data in Fig. 2. We observe that 1) lower layers have smaller constraints and higher layers have larger constraints, meaning more freedom to grow, and 2) with only " + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "inline_equation", + "content": "10\\%" + }, + { + "bbox": [ + 304, + 521, + 547, + 715 + ], + "type": "text", + "content": " training" + } + ] + } + ], + "index": 9 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 46, + 683, + 287, + 715 + ], + "type": "page_footnote", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 683, + 287, + 715 + ], + "spans": [ + { + "bbox": [ + 46, + 683, + 287, + 715 + ], + "type": "text", + "content": "2TPGM on MocoV3 is the only situation where we found total variation smoothing (see Appendix 5.3) helps with ID performance. Without smoothing, TPGM achieves 81.66 ID and 37.27 Ave. OOD performance." + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 295, + 748, + 314, + 758 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 314, + 758 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 314, + 758 + ], + "type": "text", + "content": "7841" + } + ] + } + ], + "index": 11 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 5 + }, + { + "para_blocks": [ + { + "type": "table", + "bbox": [ + 85, + 102, + 507, + 201 + ], + "blocks": [ + { + "bbox": [ + 46, + 70, + 547, + 95 + ], + "lines": [ + { + "bbox": [ + 46, + 70, + 547, + 95 + ], + "spans": [ + { + "bbox": [ + 46, + 70, + 547, + 95 + ], + "type": "text", + "content": "Table 3. DomainNet Results using CLIP pre-trained ResNet50 with " + }, + { + "bbox": [ + 46, + 70, + 547, + 95 + ], + "type": "inline_equation", + "content": "10\\%" + }, + { + "bbox": [ + 46, + 70, + 547, + 95 + ], + "type": "text", + "content": " Real Data. TPGM adjusts to the size of the fine-tuning dataset by imposing stronger per-layer constraints." + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 85, + 102, + 507, + 201 + ], + "lines": [ + { + "bbox": [ + 85, + 102, + 507, + 201 + ], + "spans": [ + { + "bbox": [ + 85, + 102, + 507, + 201 + ], + "type": "table", + "html": "
ID RealOODStatistics
SketchPaintingInfographClipartOOD Avg.ID Δ (%)OOD Δ (%)
Vanilla FT57.35 (1.43)17.48 (0.68)25.60 (0.70)10.30 (1.57)23.01 (0.65)19.100.000.00
LP47.19 (0.93)17.81 (0.25)22.71 (2.08)17.13 (0.75)17.59 (0.69)18.81-17.71-1.52
PF [19]71.04 (0.91)27.87 (1.04)38.31 (1.05)19.85 (0.70)33.92 (1.53)29.9923.8657.01
L2-SP [44]61.41 (0.92)22.61 (0.52)30.48 (0.42)12.28 (0.50)26.59 (0.57)22.997.0820.37
MARS-SP [9]52.53 (0.84)15.34 (0.54)21.57 (0.45)8.49 (0.60)19.96 (0.01)16.34-8.41-14.44
LP-FT [21]64.11 (0.78)20.54 (0.27)30.89 (0.41)13.58 (0.63)29.55 (0.82)23.6411.7823.77
TPGM73.16 (1.27)29.88 (0.81)36.80 (1.42)19.72 (0.12)35.28 (0.74)30.4227.5659.27
", + "image_path": "b7c2f016f04310fa03723a86e001f797a27ffdcfab2a15abfb026c4e7e5998bc.jpg" + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "table_body" + } + ], + "index": 1 + }, + { + "bbox": [ + 46, + 220, + 288, + 280 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 220, + 288, + 280 + ], + "spans": [ + { + "bbox": [ + 46, + 220, + 288, + 280 + ], + "type": "text", + "content": "data, the learned constraints are much smaller than those trained with " + }, + { + "bbox": [ + 46, + 220, + 288, + 280 + ], + "type": "inline_equation", + "content": "100\\%" + }, + { + "bbox": [ + 46, + 220, + 288, + 280 + ], + "type": "text", + "content": ". This behavior explains why TPGM maintains high ID performance and avoids over-fitting with fewer training data because it chooses to rely more on the pre-trained model by enforcing stronger projection." + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 47, + 287, + 255, + 300 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 47, + 287, + 255, + 300 + ], + "spans": [ + { + "bbox": [ + 47, + 287, + 255, + 300 + ], + "type": "text", + "content": "4.2. Fine-tuning a Pre-Trained Transformer" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "spans": [ + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "text", + "content": "In this section, we compare to existing fine-tuning methods using a CLIP pre-trained ViT-B model. We initialize all models with the pre-trained weights and also the last linear classifier layer with a zero-shot classifier extracted from the CLIP text-encoder. Specifically, for TPGM, we use " + }, + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "inline_equation", + "content": "f_{proj} = T - 1" + }, + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "text", + "content": " and " + }, + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "inline_equation", + "content": "T_{proj} = 200" + }, + { + "bbox": [ + 45, + 305, + 287, + 496 + ], + "type": "text", + "content": ", meaning that projection only happens once at the end of fine-tuning. This is possible because CLIP pre-trained ViT-B has been shown to have good linear connectivity [41] in contrast to the CLIP pre-trained ResNet (Appendix 5.7). Furthermore, we use L2 projection in Eq. 3 because we found L2 projection is better than MARS projection in this setting (Appendix 5.6). Training Transformers [37] requires careful tuning of the training recipe to achieve the best results3. We follow some common practices in prior works [34, 35] to boost performance. We leave implementation details in Appendix 5.4." + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "spans": [ + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": "Extracting a Zero-Shot Classifier. CLIP has an image-encoder " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "g(\\cdot)" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": " and a text-encoder " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "h(\\cdot)" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", and is capable of zero-shot classification. For example, given an image " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "x" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": " and its label space " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "y \\in \\mathcal{Y} = \\{y_1, \\dots, y_c\\}" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", zero-shot classification can be done by first inserting the class name " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "y_i" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", e.g., \"apple\", into a template " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "c_i" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", e.g., \"a photo of {apple}\" and extracting its text embedding " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "h(c_i)" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", and then computing an inner product, " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "\\langle h(c_i), g(x) \\rangle" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", between the text embedding and the corresponding image embedding. The maximum value of the inner product over all classes determines the membership of the input. Following the prior work [41], one can stack " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "h(c_i)" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": ", " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "\\forall i \\in \\{1, \\dots, c\\}" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": " into a weight matrix " + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "inline_equation", + "content": "\\mathbf{W}_{\\text{zero-shot}}" + }, + { + "bbox": [ + 46, + 497, + 288, + 663 + ], + "type": "text", + "content": " as a zero-shot classification layer. We use this weight matrix as initialization as well as zero-shot classification." + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 59, + 664, + 287, + 677 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 59, + 664, + 287, + 677 + ], + "spans": [ + { + "bbox": [ + 59, + 664, + 287, + 677 + ], + "type": "text", + "content": "TPGM Improves OOD robustness without sacrificing" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 46, + 683, + 288, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 683, + 288, + 715 + ], + "spans": [ + { + "bbox": [ + 46, + 683, + 288, + 715 + ], + "type": "text", + "content": "Our training recipe yields 84.20 vanilla FT accuracy on ImageNet using a CLIP ViT-B, which is significantly better than prior works, e.g., WISE [41] reported 81.3, FT-LP [28] reported 81.7 on the same dataset." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 304, + 220, + 547, + 472 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 220, + 547, + 472 + ], + "spans": [ + { + "bbox": [ + 304, + 220, + 547, + 472 + ], + "type": "text", + "content": "ID performance. Now, we present the main benchmark results, accuracy on each of the datasets, and percentage of improvement with respect to the vanilla FT method, in Tab. 4. Parameter-efficient methods such as LP and BitFit all improve OOD generalization however at a loss of ID performance. We hypothesize that they help preserve generalization by updating fewer parameters in the network, and therefore maintaining a closer distance to the pre-trained model. On the other hand, the restriction on the function space can result in under-fitting, manifested in lower ID performance. Surprisingly, L2-SP and LP-FT fail to improve either ID or OOD performance. We think this is because the added regularization in L2-SP and the two-stage training procedure in LP-FT are not very compatible with the existing Transformer training recipe. The zero-shot classifier brings significant OOD improvement even though the ID performance is way worse than the FT model. This confirms that CLIP models acquire great generalization capability during pre-training, as also reported by the original paper [28]. TPGM and WISE perform notably better than other methods. We will elaborate on the comparison next." + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "spans": [ + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "text", + "content": "TPGM outperforms WISE. The current state-of-the-art method for fine-tuning a pre-trained model with linear connectivity is WISE [41], which linearly interpolates between a fine-tuned model and the pre-trained model with a single ratio. For lack of a better heuristic, the paper suggests 0.5 as the interpolation ratio and leaves the research for a better method to determine the mixing ratio as an open question. The comparison between TPGM and WISE comes down to the comparison between optimized per-layer constraints and a hand-tuned single constraint. Therefore, for WISE, we sweep different ratios from 0.1 to 0.9, controlling the distance to the pre-trained model from close to far. For TPGM, to fairly compare to WISE, we put an L2 regularization on the magnitude of the trainable projection parameters with a hyperparameter " + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "inline_equation", + "content": "\\mu" + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "text", + "content": " that controls the strength of regularization. Intuitively, a larger regularization forces the projection radii to be smaller, meaning projecting the fine-tuned model closer to the pre-trained model. We sweep a range of different " + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "inline_equation", + "content": "\\mu" + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "text", + "content": " from " + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "inline_equation", + "content": "4e^{-3}" + }, + { + "bbox": [ + 304, + 474, + 547, + 715 + ], + "type": "text", + "content": " to 0.0. We refer to this variant as TPGM-C (C for controlled). Note that this L2 regu" + } + ] + } + ], + "index": 9 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7842" + } + ] + } + ], + "index": 10 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 6 + }, + { + "para_blocks": [ + { + "type": "table", + "bbox": [ + 85, + 134, + 507, + 242 + ], + "blocks": [ + { + "bbox": [ + 46, + 70, + 547, + 126 + ], + "lines": [ + { + "bbox": [ + 46, + 70, + 547, + 126 + ], + "spans": [ + { + "bbox": [ + 46, + 70, + 547, + 126 + ], + "type": "text", + "content": "Table 4. ImageNet Results using CLIP pre-trained ViT-B. TPGM improves OOD performance significantly without losing ID performance. TPGM-C achieves the best OOD performance while maintaining a more competitive ID performance compared to the current state-of-the-art method WISE. TPGM-C is a controlled variant of TPGM, designed to lower its ID performance to the same level as WISE for a fair comparison of OOD performance. Note that prior works [41] sub-sample classes for ImageNet-A/R (200 classes) for evaluation while we do not." + } + ] + } + ], + "index": 0, + "angle": 0, + "type": "table_caption" + }, + { + "bbox": [ + 85, + 134, + 507, + 242 + ], + "lines": [ + { + "bbox": [ + 85, + 134, + 507, + 242 + ], + "spans": [ + { + "bbox": [ + 85, + 134, + 507, + 242 + ], + "type": "table", + "html": "
IDOODStatistics
ImageNetImageNet-V2ImageNet-AImageNet-RImageNet-SID Avg.OOD Avg.ID Δ (%)OOD Δ (%)
Vanilla FT84.20 (0.02)75.08 (0.11)26.52 (0.12)46.45 (0.06)48.90 (0.58)79.6440.630.000.00
LP77.99 (0.02)67.74 (0.04)27.13 (0.06)50.71 (0.07)46.47 (0.04)72.8641.44-8.512.00
BitFit [48]78.02 (0.12)67.69 (0.15)27.19 (0.28)50.66 (0.31)46.50 (0.29)72.8541.45-8.422.45
L2-SP [44]84.10 (0.02)75.05 (0.11)26.19 (0.45)46.58 (0.09)48.51 (0.12)79.5840.43-0.08-0.49
LP-FT [21]83.50 (0.15)73.95 (0.12)25.62 (0.23)46.21 (0.22)48.83 (0.19)78.7340.22-1.15-1.00
Zero-Shot [28]67.68 (N/A)61.41 (N/A)30.60 (N/A)56.77 (N/A)45.53 (N/A)64.5444.30-18.918.64
WISE [41]82.11 (0.14)73.61 (0.13)36.11 (0.16)61.77 (0.08)54.16 (0.07)77.8650.68-2.2324.75
TPGM-C82.41 (0.07)73.91 (0.21)36.79 (0.14)62.48 (0.10)54.91 (0.12)78.1651.39-1.8626.51
TPGM84.19 (0.03)75.41 (1.61)34.29 (2.11)57.19 (0.54)54.38 (0.19)79.8048.620.2019.69
", + "image_path": "79dde2feaf7846ab09a79dc5729476fc92459773aa608c0fa7716a716e034011.jpg" + } + ] + } + ], + "index": 1, + "angle": 0, + "type": "table_body" + } + ], + "index": 1 + }, + { + "type": "image", + "bbox": [ + 60, + 260, + 279, + 352 + ], + "blocks": [ + { + "bbox": [ + 60, + 260, + 279, + 352 + ], + "lines": [ + { + "bbox": [ + 60, + 260, + 279, + 352 + ], + "spans": [ + { + "bbox": [ + 60, + 260, + 279, + 352 + ], + "type": "image", + "image_path": "c92d2019145ca6677d7b368625ddec00320ea01f619acd1eff655164d2ff18c7.jpg" + } + ] + } + ], + "index": 2, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 46, + 360, + 288, + 416 + ], + "lines": [ + { + "bbox": [ + 46, + 360, + 288, + 416 + ], + "spans": [ + { + "bbox": [ + 46, + 360, + 288, + 416 + ], + "type": "text", + "content": "Figure 3. ID and OOD performance of TPGM and WISE with different hyperparameters using CLIP pre-trained ViT-B, fine-tuned on ImageNet. Sweeping different hyperparameters for both WISE and TPGM shows that learning per-layer constraints is superior to learning a single constraint." + } + ] + } + ], + "index": 3, + "angle": 0, + "type": "image_caption" + } + ], + "index": 2 + }, + { + "type": "image", + "bbox": [ + 58, + 434, + 279, + 522 + ], + "blocks": [ + { + "bbox": [ + 58, + 434, + 279, + 522 + ], + "lines": [ + { + "bbox": [ + 58, + 434, + 279, + 522 + ], + "spans": [ + { + "bbox": [ + 58, + 434, + 279, + 522 + ], + "type": "image", + "image_path": "0da83a574f0770b43e24c3dcbc9c5bef615b8fdec160c47d9af7f084ece44333.jpg" + } + ] + } + ], + "index": 4, + "angle": 0, + "type": "image_body" + }, + { + "bbox": [ + 46, + 534, + 288, + 579 + ], + "lines": [ + { + "bbox": [ + 46, + 534, + 288, + 579 + ], + "spans": [ + { + "bbox": [ + 46, + 534, + 288, + 579 + ], + "type": "text", + "content": "Figure 4. Average distance between the fine-tuned model and a CLIP pre-trained ViT-B for each block using TPGM. Compared to the original distance learned by Vanilla FT, TPGM more aggressively constrains the distance of lower layers." + } + ] + } + ], + "index": 5, + "angle": 0, + "type": "image_caption" + } + ], + "index": 4 + }, + { + "bbox": [ + 46, + 594, + 289, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 46, + 594, + 289, + 715 + ], + "spans": [ + { + "bbox": [ + 46, + 594, + 289, + 715 + ], + "type": "text", + "content": "larization is not a hyper-parameter in the algorithm itself. In Fig. 3, we observe a trade-off between the ID performance and the OOD performance for both methods. However, TPGM clearly outperforms WISE because for the same ID performance, TPGM has better OOD performance and for the same OOD performance, TPGM has better ID performance. This demonstrates the benefits of maintaining per-layer constraints over a single interpolation ratio. We also provide the same experiment and visualization using a CLIP pre-trained ViT-L in Appendix 5.5." + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 304, + 260, + 547, + 490 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 260, + 547, + 490 + ], + "spans": [ + { + "bbox": [ + 304, + 260, + 547, + 490 + ], + "type": "text", + "content": "Different layers require different regularization. Now we take a closer look at the learned TPGM projection radii especially in terms of \"closeness\" to the pre-trained model. In Fig. 4, we visualize the average distance from the pretrained model for each transformer block with three different L2 regularization strengths. We observe that 1) lower layers have smaller projection radii, i.e., they are more tightly constrained whereas higher layers have larger projection radii and therefore more freedom to grow; 2) as the regularization strength on projection radii increases, on average, they become closer to the pre-trained model while still following the previous observation. Combined with the common belief that lower layers learn more general features and higher layers learn more specialized layers, we hypothesize that lower layers of the pre-trained model are \"closer\" to the ideal model than higher layers. This observation corroborates with our theoretical analysis (Sec. 3.4) that when the distance between the pre-trained model and the ideal model is small, TPGM favors close projection." + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 306, + 510, + 379, + 522 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 306, + 510, + 379, + 522 + ], + "spans": [ + { + "bbox": [ + 306, + 510, + 379, + 522 + ], + "type": "text", + "content": "5. Conclusion" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 304, + 534, + 547, + 715 + ], + "type": "text", + "angle": 0, + "lines": [ + { + "bbox": [ + 304, + 534, + 547, + 715 + ], + "spans": [ + { + "bbox": [ + 304, + 534, + 547, + 715 + ], + "type": "text", + "content": "Proposing a bi-level constrained minimization formulation of fine-tuning, we develop the trainable projected gradient method (TPGM) to learn a distance constraint for each layer of a neural network for robust fine-tuning, which has not been possible with manual hyper-parameter tuning. Our thorough experiments across several pretrained models and ID/OOD datasets show that TPGM can better preserve the OOD generalization capability of the pre-trained model with minimal effects on ID performance. The optimized constraints exhibit highly interpretable patterns which corroborate existing findings and strengthen the motivation for per-layer constraints. Moreover, our algorithm is general with different possibilities for various components, such as the projection operator, and thereby opens up opportunities for future research." + } + ] + } + ], + "index": 9 + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7843" + } + ] + } + ], + "index": 10 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 7 + }, + { + "para_blocks": [ + { + "bbox": [ + 48, + 71, + 106, + 83 + ], + "type": "title", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 71, + 106, + 83 + ], + "spans": [ + { + "bbox": [ + 48, + 71, + 106, + 83 + ], + "type": "text", + "content": "References" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 48, + 91, + 287, + 713 + ], + "type": "list", + "angle": 0, + "index": 15, + "blocks": [ + { + "bbox": [ + 53, + 91, + 287, + 133 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 91, + 287, + 133 + ], + "spans": [ + { + "bbox": [ + 53, + 91, + 287, + 133 + ], + "type": "text", + "content": "[1] Qiang Chen, Philippe Montesinos, Quan Sen Sun, Peng Ann Heng, et al. Adaptive total variation denoising based on difference curvature. Image and vision computing, 28(3):298-306, 2010. 4, 12" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 53, + 136, + 287, + 178 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 136, + 287, + 178 + ], + "spans": [ + { + "bbox": [ + 53, + 136, + 287, + 178 + ], + "type": "text", + "content": "[2] Xinlei Chen, Saining Xie, and Kaiming He. An empirical study of training self-supervised vision transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9640-9649, 2021. 5" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 53, + 180, + 287, + 212 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 180, + 287, + 212 + ], + "spans": [ + { + "bbox": [ + 53, + 180, + 287, + 212 + ], + "type": "text", + "content": "[3] Laurent Condat. A direct algorithm for 1-d total variation denoising. IEEE Signal Processing Letters, 20(11):1054-1057, 2013. 4, 12" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 53, + 214, + 287, + 257 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 214, + 287, + 257 + ], + "spans": [ + { + "bbox": [ + 53, + 214, + 287, + 257 + ], + "type": "text", + "content": "[4] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248-255. IEEE, 2009. 2, 5" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 53, + 258, + 287, + 290 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 258, + 287, + 290 + ], + "spans": [ + { + "bbox": [ + 53, + 258, + 287, + 290 + ], + "type": "text", + "content": "[5] Terrance DeVries and Graham W Taylor. Learning confidence for out-of-distribution detection in neural networks. arXiv preprint arXiv:1802.04865, 2018. 3" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 53, + 292, + 287, + 324 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 292, + 287, + 324 + ], + "spans": [ + { + "bbox": [ + 53, + 292, + 287, + 324 + ], + "type": "text", + "content": "[6] Simon S Du, Wei Hu, Sham M Kakade, Jason D Lee, and Qi Lei. Few-shot learning via learning the representation, provably. arXiv preprint arXiv:2002.09434, 2020. 4" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 53, + 326, + 287, + 369 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 326, + 287, + 369 + ], + "spans": [ + { + "bbox": [ + 53, + 326, + 287, + 369 + ], + "type": "text", + "content": "[7] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. In International Conference on Machine Learning, pages 3259-3269. PMLR, 2020. 3" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 53, + 370, + 287, + 434 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 370, + 287, + 434 + ], + "spans": [ + { + "bbox": [ + 53, + 370, + 287, + 434 + ], + "type": "text", + "content": "[8] Jonathan Godwin, Michael Schaarschmidt, Alexander L Gaunt, Alvaro Sanchez-Gonzalez, Yulia Rubanova, Petar Velickovic, James Kirkpatrick, and Peter Battaglia. Simple gnn regularisation for 3d molecular property prediction and beyond. In International conference on learning representations, 2021. 2" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 53, + 436, + 287, + 468 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 53, + 436, + 287, + 468 + ], + "spans": [ + { + "bbox": [ + 53, + 436, + 287, + 468 + ], + "type": "text", + "content": "[9] Henry Gouk, Timothy M Hospedales, and Massimiliano Pontil. Distance-based regularisation of deep networks for fine-tuning. *ICLR*, 2021. 1, 3, 6, 7, 12" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 48, + 470, + 287, + 512 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 470, + 287, + 512 + ], + "spans": [ + { + "bbox": [ + 48, + 470, + 287, + 512 + ], + "type": "text", + "content": "[10] Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In International conference on machine learning, pages 1321-1330. PMLR, 2017. 2" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 48, + 514, + 287, + 568 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 514, + 287, + 568 + ], + "spans": [ + { + "bbox": [ + 48, + 514, + 287, + 568 + ], + "type": "text", + "content": "[11] Yunhui Guo, Honghui Shi, Abhishek Kumar, Kristen Grauman, Tajana Rosing, and Rogerio Feris. Spottune: transfer learning through adaptive fine-tuning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 4805-4814, 2019. 2" + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 48, + 570, + 287, + 623 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 570, + 287, + 623 + ], + "spans": [ + { + "bbox": [ + 48, + 570, + 287, + 623 + ], + "type": "text", + "content": "[12] Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollár, and Ross Girshick. Masked autoencoders are scalable vision learners. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 16000-16009, 2022. 13" + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 48, + 625, + 287, + 666 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 625, + 287, + 666 + ], + "spans": [ + { + "bbox": [ + 48, + 625, + 287, + 666 + ], + "type": "text", + "content": "[13] Kaiming He, Ross Girshick, and Piotr Dólar. Rethinking imageNet pre-training. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4918-4927, 2019. 2" + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 48, + 670, + 287, + 713 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 670, + 287, + 713 + ], + "spans": [ + { + "bbox": [ + 48, + 670, + 287, + 713 + ], + "type": "text", + "content": "[14] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770-778, 2016. 5, 12" + } + ] + } + ], + "index": 14 + } + ], + "sub_type": "ref_text" + }, + { + "bbox": [ + 307, + 73, + 545, + 713 + ], + "type": "list", + "angle": 0, + "index": 31, + "blocks": [ + { + "bbox": [ + 307, + 73, + 545, + 139 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 73, + 545, + 139 + ], + "spans": [ + { + "bbox": [ + 307, + 73, + 545, + 139 + ], + "type": "text", + "content": "[15] Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 8340-8349, 2021. 5" + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 307, + 140, + 545, + 182 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 140, + 545, + 182 + ], + "spans": [ + { + "bbox": [ + 307, + 140, + 545, + 182 + ], + "type": "text", + "content": "[16] Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. In International Conference on Machine Learning, pages 2712-2721. PMLR, 2019. 3" + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 307, + 184, + 545, + 227 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 184, + 545, + 227 + ], + "spans": [ + { + "bbox": [ + 307, + 184, + 545, + 227 + ], + "type": "text", + "content": "[17] Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15262-15271, 2021. 5" + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 307, + 228, + 545, + 259 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 228, + 545, + 259 + ], + "spans": [ + { + "bbox": [ + 307, + 228, + 545, + 259 + ], + "type": "text", + "content": "[18] Alfredo N Iusem. On the convergence properties of the projected gradient method for convex optimization. Computational & Applied Mathematics, 22:37-52, 2003. 3" + } + ] + } + ], + "index": 19 + }, + { + "bbox": [ + 307, + 261, + 545, + 304 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 261, + 545, + 304 + ], + "spans": [ + { + "bbox": [ + 307, + 261, + 545, + 304 + ], + "type": "text", + "content": "[19] Fahdi Kanavati and Masayuki Tsuneki. Partial transfusion: on the expressive influence of trainable batch norm parameters for transfer learning. In Medical Imaging with Deep Learning, pages 338-353. PMLR, 2021. 6, 7, 12" + } + ] + } + ], + "index": 20 + }, + { + "bbox": [ + 307, + 305, + 545, + 337 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 305, + 545, + 337 + ], + "spans": [ + { + "bbox": [ + 307, + 305, + 545, + 337 + ], + "type": "text", + "content": "[20] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 4, 5, 12" + } + ] + } + ], + "index": 21 + }, + { + "bbox": [ + 307, + 338, + 545, + 370 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 338, + 545, + 370 + ], + "spans": [ + { + "bbox": [ + 307, + 338, + 545, + 370 + ], + "type": "text", + "content": "[21] Ananya Kumar et al. Fine-tuning can distort pretrained features and underperform out-of-distribution. *ICLR*, 2022. 3, 6, 7, 8, 12, 13" + } + ] + } + ], + "index": 22 + }, + { + "bbox": [ + 307, + 372, + 545, + 415 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 372, + 545, + 415 + ], + "spans": [ + { + "bbox": [ + 307, + 372, + 545, + 415 + ], + "type": "text", + "content": "[22] Yoonho Lee, Annie S Chen, Fahim Tajwar, Ananya Kumar, Huaxiu Yao, Percy Liang, and Chelsea Finn. Surgical fine-tuning improves adaptation to distribution shifts. arXiv preprint arXiv:2210.11466, 2022. 2" + } + ] + } + ], + "index": 23 + }, + { + "bbox": [ + 307, + 416, + 545, + 459 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 416, + 545, + 459 + ], + "spans": [ + { + "bbox": [ + 307, + 416, + 545, + 459 + ], + "type": "text", + "content": "[23] Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, Zeyu Chen, and Jun Huan. Delta: Deep learning transfer using feature map with attention for convolutional networks. arXiv preprint arXiv:1901.09229, 2019. 2" + } + ] + } + ], + "index": 24 + }, + { + "bbox": [ + 307, + 460, + 545, + 481 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 460, + 545, + 481 + ], + "spans": [ + { + "bbox": [ + 307, + 460, + 545, + 481 + ], + "type": "text", + "content": "[24] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017. 13" + } + ] + } + ], + "index": 25 + }, + { + "bbox": [ + 307, + 483, + 545, + 525 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 483, + 545, + 525 + ], + "spans": [ + { + "bbox": [ + 307, + 483, + 545, + 525 + ], + "type": "text", + "content": "[25] Krikamol Muandet, David Balduzzi, and Bernhard Scholkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10-18. PMLR, 2013. 1" + } + ] + } + ], + "index": 26 + }, + { + "bbox": [ + 307, + 526, + 545, + 568 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 526, + 545, + 568 + ], + "spans": [ + { + "bbox": [ + 307, + 526, + 545, + 568 + ], + "type": "text", + "content": "[26] Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer learning? Advances in neural information processing systems, 33:512-523, 2020. 2, 5" + } + ] + } + ], + "index": 27 + }, + { + "bbox": [ + 307, + 570, + 545, + 623 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 570, + 545, + 623 + ], + "spans": [ + { + "bbox": [ + 307, + 570, + 545, + 623 + ], + "type": "text", + "content": "[27] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In Proceedings of the IEEE/CVF international conference on computer vision, pages 1406-1415, 2019, 2, 5" + } + ] + } + ], + "index": 28 + }, + { + "bbox": [ + 307, + 625, + 545, + 691 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 625, + 545, + 691 + ], + "spans": [ + { + "bbox": [ + 307, + 625, + 545, + 691 + ], + "type": "text", + "content": "[28] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, pages 8748-8763. PMLR, 2021. 1, 3, 5, 7, 8, 13, 14" + } + ] + } + ], + "index": 29 + }, + { + "bbox": [ + 307, + 692, + 545, + 713 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 692, + 545, + 713 + ], + "spans": [ + { + "bbox": [ + 307, + 692, + 545, + 713 + ], + "type": "text", + "content": "[29] Maithra Raghu, Chiyuan Zhang, Jon Kleinberg, and Samy Bengio. Transfusion: Understanding transfer learning for" + } + ] + } + ], + "index": 30 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7844" + } + ] + } + ], + "index": 32 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 8 + }, + { + "para_blocks": [ + { + "bbox": [ + 48, + 73, + 287, + 713 + ], + "type": "list", + "angle": 0, + "index": 15, + "blocks": [ + { + "bbox": [ + 66, + 73, + 286, + 95 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 66, + 73, + 286, + 95 + ], + "spans": [ + { + "bbox": [ + 66, + 73, + 286, + 95 + ], + "type": "text", + "content": "medical imaging. Advances in neural information processing systems, 32, 2019. 2, 5" + } + ] + } + ], + "index": 0 + }, + { + "bbox": [ + 48, + 95, + 287, + 139 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 95, + 287, + 139 + ], + "spans": [ + { + "bbox": [ + 48, + 95, + 287, + 139 + ], + "type": "text", + "content": "[30] Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, pages 5389-5400. PMLR, 2019. 5" + } + ] + } + ], + "index": 1 + }, + { + "bbox": [ + 48, + 140, + 287, + 194 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 140, + 287, + 194 + ], + "spans": [ + { + "bbox": [ + 48, + 140, + 287, + 194 + ], + "type": "text", + "content": "[31] Zhiqiang Shen, Zechun Liu, Jie Qin, Marios Savvides, and Kwang-Ting Cheng. Partial is better than all: Revisiting finetuning strategy for few-shot learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 9594–9602, 2021. 2" + } + ] + } + ], + "index": 2 + }, + { + "bbox": [ + 48, + 195, + 287, + 248 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 195, + 287, + 248 + ], + "spans": [ + { + "bbox": [ + 48, + 195, + 287, + 248 + ], + "type": "text", + "content": "[32] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2818-2826, 2016. 13" + } + ] + } + ], + "index": 3 + }, + { + "bbox": [ + 48, + 250, + 287, + 294 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 250, + 287, + 294 + ], + "spans": [ + { + "bbox": [ + 48, + 250, + 287, + 294 + ], + "type": "text", + "content": "[33] Junjiao Tian, Dylan Yung, Yen-Chang Hsu, and Zsolt Kira. A geometric perspective towards neural calibration via sensitivity decomposition. Advances in Neural Information Processing Systems, 34:26358-26369, 2021. 1" + } + ] + } + ], + "index": 4 + }, + { + "bbox": [ + 48, + 294, + 287, + 348 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 294, + 287, + 348 + ], + "spans": [ + { + "bbox": [ + 48, + 294, + 287, + 348 + ], + "type": "text", + "content": "[34] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. In International Conference on Machine Learning, pages 10347-10357. PMLR, 2021. 7, 12, 13" + } + ] + } + ], + "index": 5 + }, + { + "bbox": [ + 48, + 350, + 287, + 380 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 350, + 287, + 380 + ], + "spans": [ + { + "bbox": [ + 48, + 350, + 287, + 380 + ], + "type": "text", + "content": "[35] Hugo Touvron, Matthieu Cord, and Hervé Jégou. Deit iii: Revenge of the vit. arXiv preprint arXiv:2204.07118, 2022. 7, 12" + } + ] + } + ], + "index": 6 + }, + { + "bbox": [ + 48, + 382, + 287, + 425 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 382, + 287, + 425 + ], + "spans": [ + { + "bbox": [ + 48, + 382, + 287, + 425 + ], + "type": "text", + "content": "[36] Nilesh Tripuraneni, Michael Jordan, and Chi Jin. On the theory of transfer learning: The importance of task diversity. Advances in Neural Information Processing Systems, 33:7852-7862, 2020. 4" + } + ] + } + ], + "index": 7 + }, + { + "bbox": [ + 48, + 426, + 287, + 470 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 426, + 287, + 470 + ], + "spans": [ + { + "bbox": [ + 48, + 426, + 287, + 470 + ], + "type": "text", + "content": "[37] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017. 2, 5, 7, 12" + } + ] + } + ], + "index": 8 + }, + { + "bbox": [ + 48, + 471, + 287, + 514 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 471, + 287, + 514 + ], + "spans": [ + { + "bbox": [ + 48, + 471, + 287, + 514 + ], + "type": "text", + "content": "[38] Haohan Wang, Songwei Ge, Zachary Lipton, and Eric P Xing. Learning robust global representations by penalizing local predictive power. Advances in Neural Information Processing Systems, 32, 2019. 5" + } + ] + } + ], + "index": 9 + }, + { + "bbox": [ + 48, + 515, + 287, + 536 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 515, + 287, + 536 + ], + "spans": [ + { + "bbox": [ + 48, + 515, + 287, + 536 + ], + "type": "text", + "content": "[39] Mei Wang and Weihong Deng. Deep visual domain adaptation: A survey. Neurocomputing, 312:135-153, 2018. 1" + } + ] + } + ], + "index": 10 + }, + { + "bbox": [ + 48, + 537, + 287, + 580 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 537, + 287, + 580 + ], + "spans": [ + { + "bbox": [ + 48, + 537, + 287, + 580 + ], + "type": "text", + "content": "[40] Yang Wen, Leiting Chen, Yu Deng, and Chuan Zhou. Rethinking pre-training on medical imaging. Journal of Visual Communication and Image Representation, 78:103145, 2021. 2" + } + ] + } + ], + "index": 11 + }, + { + "bbox": [ + 48, + 581, + 287, + 657 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 581, + 287, + 657 + ], + "spans": [ + { + "bbox": [ + 48, + 581, + 287, + 657 + ], + "type": "text", + "content": "[41] Mitchell Wortsman, Gabriel Ilharco, Jong Wook Kim, Mike Li, Simon Kornblith, Rebecca Roelofs, Raphael Gontijo Lopes, Hannaneh Hajishirzi, Ali Farhadi, Hongseok Namkoong, et al. Robust fine-tuning of zero-shot models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7959-7971, 2022. 1, 2, 3, 4, 5, 7, 8, 13, 14" + } + ] + } + ], + "index": 12 + }, + { + "bbox": [ + 48, + 658, + 287, + 691 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 658, + 287, + 691 + ], + "spans": [ + { + "bbox": [ + 48, + 658, + 287, + 691 + ], + "type": "text", + "content": "[42] Sen Wu, Hongyang R Zhang, and Christopher Ré. Understanding and improving information transfer in multi-task learning. arXiv preprint arXiv:2005.00944, 2020. 4" + } + ] + } + ], + "index": 13 + }, + { + "bbox": [ + 48, + 692, + 287, + 713 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 48, + 692, + 287, + 713 + ], + "spans": [ + { + "bbox": [ + 48, + 692, + 287, + 713 + ], + "type": "text", + "content": "[43] Sang Michael Xie, Ananya Kumar, Robbie Jones, Fereshte Khani, Tengyu Ma, and Percy Liang. In-n-out: Pre-training" + } + ] + } + ], + "index": 14 + } + ], + "sub_type": "ref_text" + }, + { + "bbox": [ + 307, + 73, + 545, + 418 + ], + "type": "list", + "angle": 0, + "index": 24, + "blocks": [ + { + "bbox": [ + 326, + 73, + 545, + 105 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 326, + 73, + 545, + 105 + ], + "spans": [ + { + "bbox": [ + 326, + 73, + 545, + 105 + ], + "type": "text", + "content": "and self-training using auxiliary information for out-of-distribution robustness. arXiv preprint arXiv:2012.04550, 2020.4" + } + ] + } + ], + "index": 16 + }, + { + "bbox": [ + 307, + 107, + 545, + 150 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 107, + 545, + 150 + ], + "spans": [ + { + "bbox": [ + 307, + 107, + 545, + 150 + ], + "type": "text", + "content": "[44] LI Xuhong, Yves Grandvalet, and Franck Davoine. Explicit inductive bias for transfer learning with convolutional networks. In International Conference on Machine Learning, pages 2825-2834. PMLR, 2018. 1, 2, 3, 6, 7, 8, 12, 13" + } + ] + } + ], + "index": 17 + }, + { + "bbox": [ + 307, + 152, + 545, + 194 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 152, + 545, + 194 + ], + "spans": [ + { + "bbox": [ + 307, + 152, + 545, + 194 + ], + "type": "text", + "content": "[45] Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? Advances in neural information processing systems, 27, 2014. 2, 5" + } + ] + } + ], + "index": 18 + }, + { + "bbox": [ + 307, + 197, + 545, + 240 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 197, + 545, + 240 + ], + "spans": [ + { + "bbox": [ + 307, + 197, + 545, + 240 + ], + "type": "text", + "content": "[46] Kaichao You, Mingsheng Long, Zhangjie Cao, Jianmin Wang, and Michael I Jordan. Universal domain adaptation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 2720-2729, 2019. 1" + } + ] + } + ], + "index": 19 + }, + { + "bbox": [ + 307, + 241, + 545, + 297 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 241, + 545, + 297 + ], + "spans": [ + { + "bbox": [ + 307, + 241, + 545, + 297 + ], + "type": "text", + "content": "[47] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE/CVF international conference on computer vision, pages 6023-6032, 2019. 13" + } + ] + } + ], + "index": 20 + }, + { + "bbox": [ + 307, + 297, + 545, + 341 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 297, + 545, + 341 + ], + "spans": [ + { + "bbox": [ + 307, + 297, + 545, + 341 + ], + "type": "text", + "content": "[48] Elad Ben Zaken, Shauli Ravfogel, and Yoav Goldberg. Bitfit: Simple parameter-efficient fine-tuning for transformer-based masked language-models. arXiv preprint arXiv:2106.10199, 2021. 8, 13" + } + ] + } + ], + "index": 21 + }, + { + "bbox": [ + 307, + 342, + 545, + 374 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 307, + 342, + 545, + 374 + ], + "spans": [ + { + "bbox": [ + 307, + 342, + 545, + 374 + ], + "type": "text", + "content": "[49] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. 13" + } + ] + } + ], + "index": 22 + }, + { + "bbox": [ + 308, + 376, + 545, + 418 + ], + "type": "ref_text", + "angle": 0, + "lines": [ + { + "bbox": [ + 308, + 376, + 545, + 418 + ], + "spans": [ + { + "bbox": [ + 308, + 376, + 545, + 418 + ], + "type": "text", + "content": "[50] Kaiyang Zhou, Ziwei Liu, Yu Qiao, Tao Xiang, and Chen Change Loy. Domain generalization: A survey. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2022. 1" + } + ] + } + ], + "index": 23 + } + ], + "sub_type": "ref_text" + } + ], + "discarded_blocks": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "page_number", + "angle": 0, + "lines": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "spans": [ + { + "bbox": [ + 295, + 748, + 315, + 757 + ], + "type": "text", + "content": "7845" + } + ] + } + ], + "index": 25 + } + ], + "page_size": [ + 612, + 792 + ], + "page_idx": 9 + } + ], + "_backend": "vlm", + "_version_name": "2.6.4" +} \ No newline at end of file