Visual Perception by Large Language Model’s Weights

Authors: feipeng  ma
hongwei  xue
yizhou  zhou
guangting  wang
fengyun  rao
shilin  yan
yueyi  zhang
siying  wu
mike zheng shou
xiaoyan  sun
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-07 14:27:00

Abstract: Existing Multimodal Large Language Models (MLLMs) follow the paradigm that perceives visual information by aligning visual features with the input space of Large Language Models (LLMs) and concatenating visual tokens with text tokens to form a unified sequence input for LLMs. These methods demonstrate promising results on various vision-language tasks but are limited by the high computational effort due to the extended input sequence resulting from the involvement of visual tokens. In this paper, instead of input space alignment, we propose a novel parameter space alignment paradigm that represents visual information as model weights. For each input image, we use a vision encoder to extract visual features, convert features into perceptual weights, and merge the perceptual weights with LLM's weights. In this way, the input of LLM does not require visual tokens, which reduces the length of the input sequence and greatly improves efficiency. Following this paradigm, we propose VLoRA with the perceptual weights generator. The perceptual weights generator is designed to convert visual features to perceptual weights with low-rank property, exhibiting a form similar to LoRA. The experimental results show that our VLoRA achieves comparable performance on various benchmarks for MLLMs, while significantly reducing the computational costs for both training and inference. Code and models are released at \url{https://github.com/FeipengMa6/VLoRA}.

Main paper: 
 introduction: 
 Large language models (LLMs) [57, 65, 47] have achieved promising performance on most natural language tasks and have shown great generalization ability in solving real-world problems. Derived from LLMs, multimodal large language models (MLLMs) [36, 66, 4, 62, 55, 48 ] take a step toward artificial general intelligence (AGI) by perceiving visual information from the real world. Therefore, the way of perceiving visual information is the key to moving from LLM to MLLM.To perceive visual information, recent MLLMs follow an input space alignment paradigm that aligns visual features with the input space of LLM and concatenates visual tokens with text tokens to form a unified sequence as input for LLM. For instance, LLaVA [36] uses CLIP-ViT-L-14 [50] as the visual encoder and introduces a linear projector to align the visual tokens with the input space of LLM. Monkey [31] divides input images into uniform patches and equips individual adapters for each The input space alignment paradigm is aligning visual features with the input space of LLM and concatenating visual tokens with text tokens as input for LLM. Our proposed VLoRA follows the parameter space alignment paradigm that aligns visual features with the parameters of LLM and merges perceptual weights generated by the perceptual weights generator with LLM's weights.architecture as the projector to improve efficiency. MiniGPT4-v1 [66] and BLIP series [27, 9] adopt Q-Former as the projector, which reduces the length of visual tokens to a fixed number of 64. Qwen-VL [5] uses a single-layer cross-attention module incorporated with 2D absolute positional encodings to avoid the potential loss of positional details. However, these improvements still follow the paradigm of aligning visual features to the input space of LLM, introducing extra computational overhead on LLM inference. Different from previous work, our VLoRA aligns visual features with the parameter space of LLM. The visual information can be represented as perceptual weights in LoRA format and merged into LLM's weights during inference.Parameter-Efficient Fine-Tuning. Parameter-efficient fine-tuning (PEFT) is a key technique for finetuning large pre-trained models, including LLMs and MLLMs. PEFT methods freeze the backbone and only fine-tune a small number of parameters, which can be typically categorized into three classes: adapters [17, 49, 54, 63] , prefix-tuning [29, 26, 38] , and Low-Rank Adaption (LoRA) [18, 37, 10] . Houlsby et al. [17] design bottleneck adapters and insert two adapters into the transformer layers, one after the attention module and one after the feed-forward network. LLaMA-Adapter [63] inserts learnable prompts into L of N decoder layers and uses zero-initialized attention for stable training. Prefix-tuning [29] prepends a set of learnable prefix vectors at the query and key of the self-attention module for every layer. Prompt-tuning proposes to only prepend learnable vectors to the input prompt with no intermediate-layer prefixes. LoRA [18] uses learnable low-rank matrices to approximate the backbone's weight updates, and the low-rank matrices can be merged with the backbone during inference without extra inference burden. Considering the pre-training stage, current MLLMs usually freeze the unimodal backbones and project visual tokens through a learnable projector, then prepend visual tokens into the input sequence of LLMs, which can be seen as prefix-tuning methods. Our VLoRA is closer to the style of LoRA. Specifically, VLoRA generates low-rank perceptual weights, which can be seen as a generated visual parameters matrix ∆W A ∈ R h×r multiplied with a learnable matrix ∆W B ∈ R r×h . Similar to LoRA, the perceptual weights can be injected into LLMs' weights without introducing extra inference overhead.HyperNetwork. HyperNetwork is a technique that employs one network to generate the weights for another network. HyperNetworks [16] proposes static hypternetwork for CNN and dynamic hypternetwork for RNN. HyperFormer [43] proposes hypterformer to generate adapter parameters for all layers and multiple tasks using shared hypternetworks. The parameter generation of both methods is designed on task-level for pre-defined tasks. HyperPELT [64] employs a shared hypernetwork that generates weights for prefix-tuning and adapter-tuning modules. MemVP [20] concatenates visual prompts with FFN weights to inject visual knowledge. In contrast to HyperNetworks and HyperFormer, 1) VLoRA focuses on sample-level parameter generation, the generated LoRA weights are conditioned on the input image without pre-defining tasks during training. Since the goal of MLLMs is to address a wide range of tasks and problems that are difficult to fully define in advance, task-level adaptation is unsuitable for MLLMs. 2) VLoRA utilizes the generated parameters in LoRA way. Sample-level parameter generation can lead to significant changes in model parameters. VLoRA, adopting the LoRA method, can better maintain the inherent capability of the pre-trained LLM. Unlike HyperPELT and MemVP, 1) VLoRA can inject visual information at any linear module, offering flexibility. 2) Unlike task-level PEFT methods, VLoRA is sample-level, generating weights for individual input images. Our evaluations, mainly in zero-shot settings, demonstrate VLoRA's strong generalization ability. 
preliminaries: 
 In this subsection, we review the details of the decoder block in the current LLM. As shown in Fig. 2 , the decoder block of LLM contains a self-attention module and a feed-forward network.Self-attention. As shown in Fig. 2 (b), the self-attention module contains four types of linear layers: query W Q ∈ R h×d , key W K ∈ R h×d , value W V ∈ R h×d , and output W O ∈ R h×h . Here, h represents the dimension of the hidden states of LLM, and d represents the dimension of each attention head. For each input tokenx i ∈ R h in the input sequence X = (x 1 , x 2 , ..., x N ), it is multiplied by linear layers W Q , W K , W V , obtaining X q = XW Q , X k = XW K and X v = XW V .Then, the attention operation is executed along the sequence dimension as follows:EQUATIONThe self-attention mechanism is performed on each head, and the outputs from different heads are concatenated and multiplied by output linear layer with weights W O .Feed-forward Network. As shown in Fig. 2 (c), the feed-forward network is an MLP with two fully connected layers and a non-linear activation function. The formulation can be written as follows:EQUATIONwhere x i is the input token, ϕ is the activation function, and W 1 and W 2 are the weights of two fully connected layers. To summarize, the decoder block of LLM has five types of weights, including W Q , W K , W V , W O from the self-attention module, and W 1 , W 2 from the feed-forward network.Previous MLLMs follow the paradigm of aligning the visual features with the input space of LLM and require additional visual tokens as LLM's input, which can lead to computational inefficiency. This inefficiency becomes more pronounced when encountering high-resolution or multiple images as the number of tokens increases drastically. To address this issue, we propose to align visual features with LLM's parameter space without introducing extra tokens into LLM's input.To achieve this goal, we represent the visual information of the input image as perceptual weights and integrate them into the weights of LLM. This approach allows LLM to perceive visual information 𝑊 ! ∈ ℝ "×$ 𝑊 % ∈ ℝ $×" ∆𝑊 ∈ ℝ "×" ∆𝑊 ! ∆𝑊 "...LoRA:Visual Parameters without introducing extra tokens into the input. As mentioned in Sect. 3.1, LLM's decoder blocks have five types of weights. We use W ∈ R h×h to denote the weight matrix of LLM. For an input image I, we first adopt a vision encoder f (•) to extract the visual features z = f (I), where z ∈ R c×dv , c is the number of visual tokens, and d v is the dimension of visual features. Then, we design a perceptual weights generator g(•) to convert the visual features to perceptual weights ∆W ∈ R h×h . It is worth noting that, given that we want LLM to perceive visual information while preserving its language capabilities, ∆W is a low-rank matrix, which also helps to reduce the computation cost of the perceptual weights generator. With the generated perceptual weights ∆W , we can directly merge it into the LLM's weights as:EQUATIONBy integrating the weights transferred from the visual features into the LLM's weights, the visual perception ability is naturally equipped. After merging the weights, no extra inference burden will be introduced for LLM. For any weights in each decoder block of LLM, we can generate the corresponding perceptual weights and integrate them into LLM's weights.To convert visual features to perceptual weights ∆W ∈ R h×h , we propose the perceptual weights generator. Since each layer and each type of weight in LLM focus on different visual information, our perceptual weights generator needs to be able to generate weights corresponding to each of the LLM weights flexibly.Inspired by DETR [6] and BLIP-2 [27] , we design the perceptual weights generator as a decoderonly architecture with cross-attention layers to generate ∆W ∈ R h×h . As shown in Fig. 3 (a) , the perceptual weights generator contains N blocks, each comprising a self-attention module, a cross-attention module, and a feed-forward network. The hidden states dimension of the perceptual weights generator is h p , where h p ≪ h • h. We set k learnable perceptual quires corresponding to the number of decoder blocks where we want to insert perceptual weights. For each block, the perceptual queries first pass through the self-attention module, then interact with visual features in the cross-attention module, and finally go through a feed-forward network. After N blocks, we obtain k features p v ∈ R hp . The features p v should be mapped to the target shape of perceptual weights ∆W ∈ R h×h . However, due to h p ≪ h • h, directly mapping the dimensions of the p v from h p to h • h with a linear layer can introduce a large number of parameters, dramatically reducing the feasibility. Therefore, we consider introducing the low-rank property in this process. We adopt a shared linear layer W share ∈ R hp×h•r to map all features p v from h p to h • r as follows:EQUATIONwhere r is the rank for perceptual weights and W v ∈ R h•r is visual parameter. And we reshape the output W v as h×r. When ascending to the target dimension h×h, k independent linear layers W s ∈ R r×h are used for each visual parameter and obtain k perceptual weights ∆W , this process can be formulated as follows:EQUATIONSubstituting Eq. ( 5) into Eq. ( 3), we get:EQUATIONConsidering the low-rank property of W v and W s , we can observe that Eq. ( 6) and LoRA [18] are of the same form, where W v corresponds to ∆W A and W s corresponds to ∆W B . As illustrated in Fig. 3 (b), our perceptual weights generator can be seen as "LoRA weights generator" from the perspective of LoRA. This is because it generates ∆W A and ∆W B for weights of LLM. Our perceptual weights generator generates one type of perceptual weights for k decoder blocks at a time. For generating multiple types of weights, we employ multiple perceptual weights generators.By not introducing additional visual tokens in the input of the LLM, our VLoRA achieves higher computational efficiency for both training and inference. We only consider the computational cost of LLM, as the computational overhead of our perceptual weights generator is negligible in comparison. We assume the LLM has d blocks and hidden states dimension of h, the input text length is C, and the number of visual tokens is L. For convenience, we only consider the computational cost of the self-attention module and feed-forward network in LLM. The FLOPs of the self-attention module and the feed-forward network are 8Lh 2 + 4L 2 h and 16Lh 2 . For previous MLLMs that align visual features to the input space of LLM, the FLOPs of LLM are 24(L + C)dh 2 + 4(L + C) 2 dh. For our VLoRA, the extra computational cost occurs in Eq. ( 6), where ∆W A is multiplied with ∆W B . Assuming that we generate perceptual weights for all 5 types of weighs in k decoder blocks. During training, we do not merge the perceptual weights with the LLM weights but use them as branches of the LLM weights. Therefore, the FLOPs are 24Cdh 2 + 4C 2 dh + 24krh 2 + 12Ckh 2 + 14Ckh. For inference, the perceptual weights can be merged into the LLM, and the FLOPs are 24Cdh 2 +4C 2 dh+24krh 2 +12kh 2 . Details of the FLOPs calculation are in the Appendix A. There is a small increase in the overhead of training compared to inference, and we compare by the training FLOPs. In Fig. 4 , we compare the FLOPs of LLaVA and VLoRA. Our approach does not introduce additional computation as the number of visual tokens increases, and our FLOPs are only 8% of LLaVA-v1.5's when the text length is 32. 
implementation details: 
 Model Settings. We use Vicuna-7b-v1.5 [65] as our foundational LLM and CLIP-ViT-L-14 [50] as vision encoder. The perceptual weights generator is initialized randomly. For the perceptual weights generator, we set the hidden size h p as 512, and the number of blocks N as 8. The rank r of perceptual weights is 64. The number of perceptual queries is 8, which means that we insert perceptual weights ∆W only on 8 blocks, and in the implementation, for Vicuna-7b-v1.5 with 32 blocks, we insert ∆W every 4 blocks. For better visual perceptual ability, we insert ∆W for all five types of weights in LLM.It is worth noting that the last k linear layers of the perceptual weights generator are zero-initialized as they are equivalent to the ∆W B of LoRA weights, which are initialized as zero for training stability.Pre-training Data. During pre-training, we use image-text pairs to train our model. Specifically, we use a subset of CapsFusion-120M [59] with 30 million image-text pairs. CapsFusion-120M randomly collects image-text pairs from LAION-COCO [1] , which contains both web-crawled and synthetic captions generated by BLIP [28] . Then, a fine-tuned LLM is used to integrate both types of captions.Pre-training Configuration. We freeze the weights of LLM and visual encoder in the pre-training stage, making only the perceptual weights generator trainable. We use the AdamW [40] optimizer with a learning rate of 5e-5, which follows a linear warm-up and then a cosine decay schedule. The pre-training is conducted with a total batch size of 768 for 40,000 iterations. The input images are resized to a resolution of 336 × 336. The pre-training stage uses 24 NVIDIA H800 GPUs for 7 hours.Fine-tuning Data. For supervised fine-tuning, we adopt the same data as LLaVA-v1.5. Specifically, the supervised fine-tuning data is constructed with VQAv2 [13] , GQA [19] , OKVQA [45] , OCRVQA [46] , A-OKVQA [52] , TextCaps [53] , RefCOCO [44, 21] , Visual Genome [23] , ShareGPT [2] , and LLaVA-Insturct [36] , with a total of 665K conversation data.Fine-tuning Configuration. During the fine-tuning stage, we freeze the vision encoder and update the weights of the perceptual weights generator and LLM. The learning rate is set to 5e-5 and the learning rate schedule is the same as in the pre-training stage. The global batch size is 128. We train for one epoch on 8 NVIDIA H800 GPUs, which takes 2 hours.MMBench & CCBench. MMBench [39] is a comprehensive multimodal benchmark designed to evaluate the performance of MLLMs. It includes over 3,000 multiple-choice questions covering 20 ability categories. The evaluation is divided into perceptual and reasoning dimensions and subdivided into 20 categories. CCBench [39] , released by the MMBench team, is designed for evaluating MLLMs in the domain of Chinese Culture.MME. MME [12] also measures the advanced MLLMs in terms of perception and cognition, with a total of 14 subtasks. To minimize the influence of prompt engineering on MLLMs, the instructions of MME are designed as simple binary responses: "please answer yes or no".ScienceQA. ScienceQA [42] is constructed from elementary and high school science curricula. Questions of ScienceQA span three subjects: natural science, language science, and social science. We use samples with images from the validation set to evaluate MLLMs.HallusionBench. HallusionBench [14] is designed for evaluating image-context reasoning, including 346 images paired with 1129 questions crafted by human experts. Unlike other benchmarks [15, 30, 33] that focus on object hallucinations with limited topics and visual input types, HallusionBench considers both language hallucinations and visual illusions across a diverse range of topics.MMMU. MMMU [60] collects 11.5K multimodal questions from college exams, quizzes, and textbooks, covering six core disciplines, spanning 30 subjects and 183 subfields, and comprising 30 heterogeneous image types. MMMU is more challenging than existing benchmarks due to the demand for college-level domain-specific knowledge.Tab. HallusionBench and even better performance on CCBench. However, the results on MME fall short of LLaVA-v1.5 since our perceptual weights generator is randomly initialized and necessitates more image-text pair data during the pre-training stage. To verify this, in Tab. 2, we reproduce LLaVA-v1.5 by replacing the projector with a randomly initialized Q-Former and achieve similar results on MME.Our VLoRA achieves comparable performance to state-of-the-art MLLMs without introducing visual tokens as LLM inputs, drastically reducing computational overhead. 
ablation study: 
 Currently, the performance of MLLMs is significantly affected by the foundational LLMs and the training data, including pre-training data and supervised fine-tuning data. To explore the effectiveness of our proposed paradigm and model, we perform a fair comparison with LLaVA-v1.5 [36] by adopting the same foundation LLM and training data in this section. Then, with this setting, we also explore the impact of different settings of each component on performance.To ensure a fair comparison with LLaVA-v1.5, we reproduce LLaVA-v1.5 with the same setting as our VLoRA, including the pre-training and supervised fine-tuning data. Furthermore, to eliminate the influence of the difference in the projector, we replace the project of LLaVA-v1.5 as a randomly initialized Q-Former, which has the same number of blocks and hidden size as our perceptual weights generator. The training is conducted using the same pre-training and fine-tuning data as VLoRA.In Tab. 2, the second row is the results of LLaVA-v1.5 pre-training on CapsFus-30m. With more pre-training data, LLaVA-v1.5 doesn't achieve significant improvement on MLLM benchmarks but rather a drop on MME, HallusionBench, MMMU, and CCBench. Our VLoRA is still comparable with the LLaVA-v1.5 training on the same data. The third row is the results of LLaVA-v1.5 with Q-Former, which is pre-trained on CapsFus-30m. We set the number of learnable queries as 128, thus the number of visual tokens is 128. Except for being slightly lower in ScienceQA and HallusionBench, our VLoRA is significantly better on other MLLM benchmarks. These results demonstrate that our approach is comparable to or even better than LLaVA-v1.5 with consistent settings. To further analyze VLoRA, we explore the impact of each component, including the type of weights that equipped perceptual weights, the rank of perceptual weights, and the number of blocks of perceptual weights generator.The type of weights that equipped perceptual weights. As we mentioned in Sect. 3.1, there are five types of weights in the decoder block of LLM, which are query, key, value, output, and mlp. We explore the impact of inserting perceptual weights for different types of LLM weights. As shown in Tab. 3, we compare different combinations, including qkvom, qkvm, qkv, qko, and qk. The model that equipped perceptual weights for all types of weights can achieve the best performance on most benchmarks. We notice that the performance of qkv is much better than qk. This suggests that the value matrix is essential for visual perception since the output of the value matrix will be weighted and summed, involving the results of the self-attention module.The rank of perceptual weights. The rank of the generated perceptual weights represents the degree of visual information compression. The smaller the rank, the more compressed the visual information. We compare the performance of rank r from 16 to 128 in Tab. 4. When the r = 16, the visual information is compressed severely in perceptual weights. However, LLM with such low-rank perceptual weights can still perceive visual information. From r = 16 to r = 64, the performance on MMBench, MME, HallusionBench, and CCBench improves with increasing rank. Specifically, the score of MMBench increases from 57.6 to 63.4, and the score of MME increases from 1163.8 to 1311.3. When the rank reaches 128, VLoRA's performance declines across these benchmarks. The reason might be that the visual information becomes redundant, and a large rank may introduce noise into the perceptual weights, which hurts LLM's capability.The number of blocks of perceptual weights generator. To explore the influence of the perceptual weights generator, we perform experiments with different numbers of blocks in the perceptual weights generator. In Tab. 5, we observe that the performance of the weights generator with 8 blocks is better than with 4 blocks. However, when it comes to N = 12, the scores on ScienceQA and CCBench are higher than with 8 blocks, but performance drops on other benchmarks. This suggests that while a stronger perceptual weights generator can achieve better performance, there is no benefit to increasing the number of blocks after the threshold is reached.Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?Answer: [Yes]Justification: We release the source code, training instructions, and model checkpoints.Guidelines:• The answer NA means that paper does not include experiments requiring code. Justification: We discuss the potential societal impacts in the Appendix. Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
conclusion: 
 In this paper, instead of aligning visual features with the input space of LLM, we propose VLoRA to align visual features with the parameter space of LLM. By not introducing visual tokens into To convert visual features into perceptual weights, we propose the perceptual weights generator to generate low-rank perceptual weights for any weights of LLM. Due to the low-rank property, the perceptual weights can be seen as LoRA weights, while ∆W A is generated and ∆W B is learnable. We perform comprehensive experiments on six MLLM benchmarks, and VLoRA can achieve comparable performance to LLaVA-v1.5 in most benchmarks while only bringing 10% computational cost as LLaVA's. In the ablation study, we reproduce LLaVA-v1.5 under the same settings and show that our method can achieve better performance. 
limitations: 
 Despite VLoRA's promising performance on various benchmarks, it still has some limitations. 1) Representing images as model weights is a previously unexplored practice, and the extracted features from existing CLIP models may not be suitable to be converted into model weights. It is necessary to explore a vision encoder that is more suitable for this paradigm. 2) We use one perceptual weights generator for one type of weight, which may lead to an insufficient correlation between different types of generated perceptual weights. It may be better to use the same perceptual weights generator to produce weights for all types at once. 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)? 
 
 Appendix: In this subsection, we give a detailed calculation of the computational overhead of VLoRA. Similar to Sect. 3.4, we assume the LLM has d blocks and hidden states dimension of h, the input text length is C, and the number of visual tokens is L. Therefore, the FLOPs of the self-attention module and the feed-forward network are 8Lh 2 +4L 2 h and 16Lh 2 . Since visual tokens are not introduced, then LLM has a computational overhead of 24Cdh 2 + 4C 2 dh for text token sequence input. For training, we use perceptual weights as branches of LLM weights. The extra computation comes from three parts: 1) the matrix multiplication of the two perceptual weights with FLOPs of 24krh 2 .2) The multiplication of the text token and the perceptual weights with FLOPs of 12Ckh 2 .3) The output coming out of the perceptual weights is to be added to the output of the LLM weights with FLOPs of 14Ckh. Therefore, the total FLOPs of VLoRA during training is 24Cdh 2 + 4C VLoRA can achieve promising results on various MLLM benchmarks, but these benchmarks are either multiple choice or judgmental, and to demonstrate VLoRA's capabilities even further, we show some real-world samples in Our proposed new paradigm significantly improves the training and inference efficiency of multimodal large models and reduces the computational overhead, which, in terms of research, can reduce the resource threshold of multimodal large model research, which is conducive to the active exploration of researchers in related fields, and, in terms of practical application, reduces the cost of large-scale deployment for use and helps to reduce the consumption of resources.We provide more results on fine-grained benchmarks for comprehensive comparisons, including TextVQA, DocVQA, InfoVQA, and OCRBench. As shown in Tab. 6, on these fine-grained benchmarks, VLoRA's performance has a gap compared to LLaVA on TextVQA and DocVQA, but it can achieve comparable results on InfoVQA. VLoRA converts CLIP's visual features into model weights, but CLIP's visual features are aligned with text rather than model parameters. Therefore, we need more diverse data to allow the weights generator to learn this transformation well. Since our pre-training data is coarse-grained image captioning data and the amount of fine-tuning data is limited, the performance of VLoRA trained on this dataset is not as good as LLaVA in some fine-grained tasks. During the prefilling stage, VLoRA saves time by not calculating the kv cache for visual tokens. In the decoding stage, VLoRA decreases the time needed to calculate attention scores with visual tokens for each new token. As a result, VLoRA maintains an advantage in inference efficiency, even when generating long sentences.Prefilling stage. Using a single A100 with flash attention, LLaVA takes 65 ms to produce the first token, whereas VLoRA only takes 45 ms. The primary time consumption for VLoRA is in weight generation, which has optimization potential, such as employing a single weight generator for all weight types.Decoding stage. With a generated sequence length set at 256, and using Flash Attention, KV Cache, and Batch Inference to maximize speed on a single A100, the inference speed of LLaVA is 410 tokens per second. In contrast, VLoRA achieves 1078 tokens per second, which is 2.6 times faster than LLaVA.NeurIPS Paper Checklist Justification: The paper fully discloses all the information needed to reproduce the main experimental results of the paper.Guidelines:• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. • Depending on the contribution, reproducibility can be accomplished in various ways.For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. , with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility.In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results. 


Decision: The work presents a novel approach for integrating visual inputs in an LLM by predicting and fusing weights instead of features. The work initially received 3BA. Post-rebuttal one of the reviewers raised their rating to WA. In the reviewer discussion phase, the reviewers showed their support for acceptance in spite of some limitations (not all results being SOTA and other practical considerations). The reviewers especially appreciated the "fresh perspective with substantial experiments and analysis", "good insights",  and the work "testing out a rather simple idea, as opposed to many recent papers which present larger, complex, and often ad-hoc solutions with very little insight". 

Having read the reviews, rebuttal and the following discussions, the AC agrees with the reviewers and recommends "accept". Congratulations to the authors!

Reviews: review: paper_summary: paper_summary: The work proposes an efficient setup for incorporating non-text modalities into pretrained LLMs for reasoning-based tasks. Instead of introducing new tokens into the LLM, they propose to dynamically generate LoRA weight matrix residuals for the linear projectors within the LLM, conditioned on the input image. The weight matrix updates, when applied to the LLM, will then alter how the LLM processes the input text.

Experimental results demonstrate competitive performance on QA tasks without the quadratic cost associated with increased input tokens.
strength_weakness: strength_weakness: - I think it's worthwhile to look beyond the QA benchmark numbers to understand what the implications of this architectural change are. If I am to understand this method correctly, the weight generator is not conditioned on the text-to-be-ingested by the LLM, which means it could drop information not typically useful for the task it's trained on. It would be curious to see how this approach compares to the more standard approach when it comes to asking questions about very obscure (or spatially tin) elements within an image.
- The approach also appears to have a pretty sensitive sweet spot for rank, which could be expensive to tune for
- From the perspective of technical novelty, I believe this is closely related to HyperNetworks https://arxiv.org/pdf/1609.09106 of which there are also transformer variants: https://arxiv.org/pdf/2106.04489 . The authors should probably include a relevant related-works section for this as well, and perhaps some additional comparisons against adaptation techniques proposed there as well. I think the goal would be to demonstrate that the proposed approach works best when it comes to sample-level adaptations, as compared to the typical task-level adaptations.
questions: questions: See weaknesses
limitations: limitations: Yes
paper_summary: paper_summary: The paper proposes a novel way to enable visual understanding in LLMs. Instead of encoding image as visual tokens, the paper proposes converting visual input to low-rank perceptual weights which are merged with LLM weights (similar to LoRA). The paper shows that the proposed approach achieves comparable performance on various single image V+L benchmarks, while significantly reducing computational cost.
strength_weakness: strength_weakness: While the method is interesting, and novel,  several practical questions remain that affect the flexibility of that method:  
- How will the model work when more than one image is used as input (such as interleaved image-text dialogue, videos, etc).   
- While the method achieves better GFLOPS than existing paradigm of using visual tokens, practical advancements (FlashAttention, KVCaching) significantly reduce actual computational overhead of adding more tokens. Can the authors comment on how their model compares after accounting for these tricks that people use to speed up inference? The authors can consider reporting tokens/s, and time to first token instead of GFLOPs. 
- I would have liked to see results on benchmarks which require fine-grained image understanding and spatial understanding and will potentially benefit from high-resolution like TextVQA, OKVQA, DocVQA.
questions: questions: - Can the authors comment on memory overhead during training? I imagine that storing the weights of perceptual weights generator (especially using different ones for different weight type) is expensive? 
- What is the red dotted vertical line in Figure 4 (Left)
limitations: limitations: The authors discuss some limitations, but miss many as pointed out in the weakness section. E.g., theoretical vs practical benefit when utilising modern tricks to speed up inference, as well as how to model multiple images.
paper_summary: paper_summary: This paper presents VloRA, a paradigm for building MLLMs, which aligns visual features with the parameter space of LLMs. By representing visual information as model weights, no visual tokens is need in the input, which reduces the length of the input sequence and improves efficiency.
strength_weakness: strength_weakness: (1) The paper presents the FLOPs advantage of VLoRA. However, FLOPs cannot reflect the real latency of LLMs sometimes, especially when generating a long sentence. The generation of LLMs has two stages: prefilling (calculating the KV cache and generating the first token) and decoding (generating subsequent tokens one-by-one). When generating a long sentence such as image captioning, shorter inputs can significantly reduce the prefilling time, but the decoding time is primarily determined by the length of the output. 
(2)The experiments are not sufficiently comprehensive. To benchmark against LLaVA-1.5, the (zero-shot) comparisons should also be conducted on the following tasks: VQAv2, GQA, TextVQA, VisWiz, POPE, SEED, MM-Vet. I am particularly curious about the results of TextVQA because previous papers have shown that the performance on this dataset is strongly correlated with the number of visual tokens.
(3) VLoRA can be regarded as using vision features to generate the PEFT parameters (LoRA) of LLMs. Therefore, some similar work listed as following should be discussed in detail:

[1] HyperPELT: Unified Parameter-Efficient Language Model Tuning for Both Language and Vision-and-Language Tasks. ACL 2023 Findings.
[2] LLaMA-Adapter: Efficient Fine-tuning of Language Models with Zero-init Attention. ICLR 2024.
[3] Memory-Space Visual Prompting for Efficient Vision-Language Fine-Tuning. ICML 2024.
questions: questions: (1) Please provide the experimental data about the real training speed and GPU RAM requirement of VLoRA and LLaVA.
(2) Please provide the experimental data on the inference efficiency of VLoRA and LLaVA, especially on long-sequence generation.
(3) Some recently similar work should be discussed in detail.
(4) How about the results on VQAv2, GQA, TextVQA, VisWiz, POPE, SEED, MM-Vet.
(5) Why use CapsFus-30m instead of blip-558k for pretraining? Can VeLoRA still be competitive when using a smaller blip-558k for pretraining?
limitations: limitations: This paper discusses some of the method's limitations, but I believe the discussion can be more comprehensive. See the 'Weaknesses' mentioned above.

Comments: title: No further questions
Thanks for the rebuttal.
Concerns addressed?
Concerns addressed?
Concerns addressed?
comment: Thank you, I believe my concerns have been adequately addressed and I will take into account the additional information in the final discussion phase with other reviewers.
Thank you for answering all my questions. New analysis to measure training and inference efficiency (requested by multiple reviewers) is much appreciated and makes the paper more thorough. It was also great to see experiments on more fine-grained benchmarks. Even though the numbers are lower than LLAVA, it shows opportunities for future work. I have increased the score to 6 (Weak Accept).
Dear reviewer, thank you for a thoughtful review! Are your concerns about relevant metrics and evaluation on tasks where performance strongly correlates with number of visual tokens addressed in the rebuttal?
Dear reviewer, thank you for a well thought out review! Are you concerns above extension to multiple images, gains in context of FlashAttention/KVCache, and fine grained image understanding satisfactorily addressed?
Dear reviewer, thank you for a thoughtful review! are your concerns addressed by the rebuttal?