Improving Visual Commonsense in Language Models via Multiple Image Generation

## Abstract

Abstract Commonsense reasoning is fundamentally based on multimodal knowledge. However, existing large language models (LLMs) are primarily trained using textual data only, limiting their ability to incorporate essential visual information. In contrast, Visual Language Models, which excel at visually-oriented tasks, often fail at non-visual tasks such as basic commonsense reasoning.
This divergence highlights a critical challenge - the integration of robust visual understanding with foundational text-based language reasoning. To this end, we introduce a method aimed at enhancing LLMs’ visual commonsense. Specifically, our method generates multiple images based on the input text prompt and integrates these into the model’s decision-making process by mixing their prediction probabilities. To facilitate multimodal grounded language modeling, we employ a late-fusion layer that combines the projected visual features with the output of a pre-trained LLM conditioned on text only. This late-fusion layer enables predictions based on comprehensive image-text knowledge as well as text only when this is required. We evaluate our approach using several visual commonsense reasoning tasks together with traditional NLP tasks, including common sense reasoning and reading comprehension. Our experimental results demonstrate significant superiority over existing baselines. When applied to recent state-of-the-art LLMs (e.g., Llama3), we observe improvements not only in visual common sense but also in traditional NLP benchmarks. Code and models are available under https://github.com/guyyariv/vLMIG .

## 1 Introduction

Large language models (LLMs) have shown significant success in advancing a variety of natural language understanding and generation tasks (Devlin et al., ; Radford et al., ; Zhang et al., ; Team et al., ; Touvron et al., ). As human knowledge is grounded in multimodal information, Vision Language Models (VLMs) have emerged, incorporating both images and text (Alayrac et al., ; Liu et al., , ; Li et al., ; Dai et al., ; Cha et al., ); thus, enabling significant advances in multimodal tasks such as visual commonsense and visual question answering (Zhang et al., ; Xia et al., ; Li et al., ; Jin et al., ).

However, while VLMs excel at visually-oriented tasks, this success often comes at the expense of their performance on non-visual tasks such as basic commonsense reasoning. This divergence highlights a critical challenge - the integration of robust visual understanding with foundational text-based language reasoning (Yun et al., ). We note that one cause for this divergence is the VLM’s overreliance on a single visual input, even when such input contains little relevant information. To mitigate this, we propose an approach comprised of two main components: (i) a novel architecture,
that allows for the late fusion of text and images, and (ii) an inference-based procedure that integrates multiple images generated by a pre-trained text-to-image model conditioned on the input text.

More specifically, in training, given an image and a corresponding caption, our method first encodes the image using a pretrained multimodal encoder, mapping the input into a common representation space of text and images. Next, this encoded representation is passed through a projector, which maps this encoding to a sequence of pseudo-text token embeddings $z^{v}_{1},\dots,z^{v}_{n}$. Simultaneously, the input text is passed through a pre-trained LLM, producing text token embeddings $z^{x}_{1},\dots,z^{x}_{k}$. Finally, we combine $z^{v}_{1},\dots,z^{v}_{n}$ and $z^{x}_{1},\dots,z^{x}_{k}$ through a late-stage attention-like mechanism, which allows for text tokens to attend to the pseudo-text tokens generated from the visual input. Unlike previous work, this integration is done once, just before the model’s prediction, and not as input to the LLM. This late fusion enables the model to focus as much as possible on the input text to predict the next token while also enabling it to use visual information if this is required to predict the next token. We find that this formulation strikes the right balance, allowing success in both visual understanding and text-based language reasoning.

The second component of our approach involves the integration of multiple visual inputs at inference. Unlike training, at inference, we do not have access to images corresponding to the input text, and so instead, we generate multiple images conditioned on the input text using a pre-trained text-to-image model. More specifically, we consider different variations of the input text and pass it to a pre-trained text-to-image generator to generate $k$ image variations. Each of the generated images is fed into our visually augmented LLM to generate $k$ different predictions (probability vectors), together with a prediction when no input image is given, thus generating $k+1$ predictions. Lastly, all probability vectors are weighted-averaged to produce the final output. By integrating different probability vectors, our prediction is based on several different visualizations, conditioned on the input text. Further, the aggregated probability vector will be highly influenced by confident predictions, being of low entropy. By providing an option not to use an input image at all, we also enable the prediction to be made based on the input text alone when this is required.

We evaluate the proposed approach on a set of object and visual common-sense tasks together with text-based common-sense reasoning. For object common sense, we employ
the zero-shot benchmark proposed by Wang et al. (), which focuses on questions related to colors, shapes, and sizes of different objects. For visual common sense, we consider a more challenging benchmark, the ImageNetVC (Xia et al., ) dataset. ImageNetVC is composed of high-quality question-answer pairs over diverse domains. For common-sense reasoning, we assess our method using standard benchmarks, similarly to Touvron et al. (); Team et al. (); Almazrouei et al. (). We also consider the task of reading comprehension, where we adhere to the benchmark framework suggested by Touvron et al. (). When considering object and visual commonsense tasks, the proposed approach significantly outperforms the evaluated baselines across a variety of architectures and model sizes.
Interestingly, following the proposed approach also slightly improves model performance in text-based common-sense reasoning tasks. We conclude the experimental section with an ablation study, analyzing the importance of each of our method’s components.

## 2 Related Work

Large Language and Vision Models. LLMs have demonstrated remarkable capabilities in various natural language processing tasks (Devlin et al., ; Radford et al., ; Zhang et al., ; Team et al., ; Touvron et al., ). Their potential expands significantly when integrated with visual modalities, giving rise to vision language models (VLMs) (Alayrac et al., ; Liu et al., , ; Li et al., ; Dai et al., ; Cha et al., ). By incorporating text and image data during training, VLMs have enabled a new set of multimodal understanding capabilities, allowing breakthroughs in tasks such as visual question answering (VQA), image captioning, and visual commonsense reasoning (Zhang et al., ; Xia et al., ; Li et al., ; Jin et al., ). Despite their exceptional performance in visually oriented tasks, VLMs frequently exhibit a drop in performance in non-visual tasks that necessitate fundamental common-sense reasoning.
In this work, we aim to improve performance in visual reasoning tasks while maintaining (or even slightly improving) common-sense reasoning compared to language models.

Visually-Augmented Language Models. Numerous studies explored approaches to augment text-only Language Models with visual information. One set of approaches retrieves images related to the input text and uses them as contextual input to the language model (Tan and Bansal, ; Lu et al., ; Wang et al., ). Similarly, Tang et al. () employs a knowledge distillation approach to fuse visual knowledge.
Other works (Zhang et al., ; Guo et al., ; Li et al., ) distill visual knowledge from multimodal embedding methods such as CLIP (Radford et al., ) into text-only language models. Another set of works utilizes pre-trained text-to-image generative models. In the context of diffusion-based text-to-image models, Z-LaVi (Yang et al., ) leverage generated visuals that match possible label predictions of a given text-only language model. Our method, instead, considers visuals that match the input text.
LiVE (Tang et al., ) introduces a vision-text plug-and-play vision-text fusion layer, which is inserted within transformed blocks of pre-trained language models (LMs). iNLG (Zhu et al., ) uses generated images
as additional visual supervision to guide the language model in text generation, where the visual input is provided as an additional input to the LM in the form of a visual prefix. Unlike LiVE and iNGL, which integrate visual knowledge as input to the LM or as an integrated layer, we, instead, use the output of an unmodified pre-trained LLM together with an encoding of a generated image, using a late-fusion layer. This enables our model to focus on the input text, while also using visual information if needed. Second, instead of using a specialized attention-like mechanism or a mapping network, our work aggregates scores simply by averaging predictions made using different generated images, obtained from variations of the input text. This enables our method to use a diverse set of predictions obtained using diverse visual “experts" and gauge its final prediction towards the more confident predictions.

Multiple Generations Agreement. Several works encourage an agreement, or consistency, between the predictions of a language model given perturbations of the input (Bachman et al., ; Sajjadi et al., ; Xie et al., ; Zhai et al., ). In contrast, we model this agreement by aggregating predictions given different visual inputs generated through a pre-trained text-to-image model conditioned on the input text. Our work is also related to the ability to obtain the confidence of LLMs, as derived by Portillo Wightman et al. (). They showed that one can estimate the confidence of LLMs by aggregating their predictions under different prompts. Our motivation is similar but uses the agreement of different visually generated inputs. In addition, while their work focuses on estimating confidence, our work aims at improving visual commonsense reasoning.

Figure: Figure 1: Illustration of the proposed method. During *training*, we utilize two types of data: (i). a pair of images and the corresponding text description, or (ii) a text and synthetically generated image conditioned on the input text. Each image is passed through a prerained vision encoder and then through a visual token projector, which projects the visual encoding onto pseudo-textual tokens. Simultaneously, the input text is passed through a pre-trained LLM, producing textual tokens. Next, our fusion layer fuses the visual pseudo-textual tokens and textual tokens and produces a prediction of the next textual token. In this fusion layer, an attention-like mechanism is performed where queries are taken to the textual tokens, and the keys and values are taken as both the textual tokens and visual pseudo-textual tokens. In blue are fixed pretrained components while in orange are trainable components. At *inference*, the same process is applied, but to $k$ different images conditionally generated using the input text. The predictions resulting from different images are then integrated as a form of ensemble using Eq. 6 and Eq. 7.
Refer to caption: x1.png

## 3 Method

The proposed approach, denoted as vLMIG, (stands for improving visual Language Models via Multiple Image Generation), aims to leverage visual cues to improve object and visual commonsense capabilities in LLMs while maintaining their performance in standard text benchmarks (i.e., commonsense reasoning and reading comprehension tasks). For that, vLMIG adopts a multi-modal learning approach, where we incorporate visual cues within textual representation to perform next-token prediction. During training, we utilize two types of input data: (i). a pair of images and their corresponding text description, and (ii). a text and a synthetically generated image obtained from a text-to-image model. During inference, given an input text prompt, we generate multiple images corresponding to different parts of the input text, feed them into the model, and aggregate their probability vectors based on their alignment with the input prompt. In the following subsections we: (i). outline the process of model optimization (Section 3.1); and (ii). introduce our visually driven inference method (Section 3.2).

### 3.1 Visually Enhanced Language Model

Our training process aims to equip the LM with the ability to utilize visual knowledge and align it with textual information. To this end, vLMIG is comprised of four main components: (i) a pre-trained Language Learning Model (LLM), (ii) a pre-trained Vision Encoder, (iii) a Visual Token Projector (VTP), and (iv) a Late Fusion Attention Layer (LFAL). To preserve the integrity of their learned representations, the Vision Encoder and the LLM are kept frozen during the training process (refer to Figure 1). The following sections will elaborate on the VTP and LFAL components.

Given an image $v\in\mathbb{R}^{3\times 224\times 224}$ and its corresponding caption $x=(x_{(1)},\ldots,x_{(n_{x})})$, where $n_{x}$ is the number of tokens in the caption, the objective during training is to minimize the negative log-likelihood:

$$ $\displaystyle\min_{\theta}\log P_{\theta}(x_{(t)}|x_{(<t)},v).$ (1) $$

Our method begins with the vision encoder $\operatorname{V}$ that extracts visual features $z^{v}=\operatorname{V}(v),$ where $z^{v}\in\mathbb{R}^{n_{v}\times d_{v}}$. These features are then transformed by the Visual Token Projector.

Visual Token Projector (VTP). The VTP intuitively projects the visual representation of the input image, $z^{v}$, into a pseudo-text latent embedding. Such representation does not represent actual words but aligns with the dimensions of the embedded text tokens, hence allowing us to fuse this visual representation with the input prompt later via attention blocks. The VTP comprises two linear layers, i.e.,

$$ $\displaystyle u^{v}=W_{1}\sigma(W_{2}z^{v}),$ (2) $$

where $W_{2}\in\mathbb{R}^{d_{v}\times d_{\text{VTP}}}$, $W_{1}\in\mathbb{R}^{d_{\text{VTP}}\times d_{x}}$, $d_{\text{VTP}}$ is the hidden embedding dimension, $\sigma$ is a non-linear function, and $d_{x}$ is the text embedding dimension of the LLM. Overall we obtain $u^{v}\in\mathbb{R}^{n_{v}\times d_{x}}$.

Late Fusion Attention Layer (LFAL). The LFAL aims to incorporate visual cues with textual context. The LFAL is a late fusion module, i.e., it is added before the logits output. The design of this layer is similar to that of a standard Transformer block. The trainable parameters of this layer are the modules that transform the input into $Q,K,V$ representations accordingly. We fuse the visual representations with the text representations by concatenating them along the time dimension,

$$ $\displaystyle K=V=[z^{v};z^{x}_{(<t)}],\quad Q=z^{x}_{(<t)},$ (3) $$

where $z^{x}$ is the latent representation of the input text obtained by the pre-trained LLM, and $K,V\in\mathbb{R}^{(t+n_{v})\times d_{x}}$, $Q\in\mathbb{R}^{t\times d_{x}}$. Thus, the attention mechanism facilitates the integration of visual context into the language model’s predictions by computing

$$ $\displaystyle\Phi\propto\left(QK^{T}\right);\quad X_{v}=\Phi\cdot V,$ (4) $$

where $\Phi\in\mathbb{R}^{t\times(t+n_{v})}$, $X_{v}\in\mathbb{R}^{t\times d_{x}}$.

Finally, we introduce a linear layer to convert the embedding dimension to the dimensions of the vocabulary size. This can be represented as:

$$ $\displaystyle\hat{X}_{v}=WX_{v},$ (5) $$

where $W\in\mathbb{R}^{d_{x}\times N}$ are the trainable weights and $N$ represents the size of the vocabulary.

### 3.2 Visually Driven Inference

vLMIG grounds the inference process with visual information. For instance, when asked, “Does the Samoyed have a spotted pattern on its back?” an image of a Samoyed could provide the necessary visual information. However, since the text lacks an associated image for visual reasoning in our inference setup, we employ a text-to-image module to generate the required images.

To enhance visual robustness, we generate $k$ images corresponding to the entire prompt. For a prompt containing multiple sentences, an image is generated per sentence. If the number of sentences does not match $k$, we randomly sample $k$ from the prompt’s pool of sentences. We also ensure that each generated image corresponding to the same sentence is generated with a unique seed.

The images are integrated as a form of ensemble, i.e., we run our model with different images, allowing for a robust visual representation. This also allows for the integration of diverse visual information, i.e.,

$$ $\displaystyle\sum_{i=1}^{k}P_{\theta}(x_{t}\mid x_{1},\ldots,x_{t-1},v_{i}).$ (6) $$

Figure: Figure 2: An illustrative example of our method at inference. On the LHS, we consider the task of visual commonsense. While Llama3’s answer is wrong, our method generates 3 images and places, for the correct class, most weight (score) on the second and third images, thus answering correctly. On the RHS, for text generation, our method generates three images for different parts of the sentence. These images are each used in our method’s answer. Llama3’s answer, on the other hand, is less visually cohesive.
Refer to caption: x2.png

To add another layer of resilience to corrupted images, we additionally measure the alignment score between the text and the generated image by applying

$$ $\displaystyle\sum_{i}^{k}f(\bar{x}_{i},v_{i})P(x_{t}\mid x_{1},\ldots,x_{t-1}, v_{i})+(1-f(\bar{x}_{i},v_{i}))P(x_{t}\mid x_{1},\ldots,x_{t-1}),$ (7) $$

where $f(\bar{x}_{i},v_{i})$ is a normalized CLIP score of the generated image $v_{i}$ and its corresponding text $\bar{x}_{i}$. This allows us to determine the confidence of the generated image w.r.t the input text. Intuitively, when the score is high, we rely more on the language model with the image guidance and otherwise on the original language model. Finally, we sample from Equation 7, to produce the text output. An example of our model’s inference is shown in Fig. 2.

## 4 Experimental Setup

### 4.1 Datasets

We optimize vLMIG using a combination of natural and artificial text-image pairs, obtained by applying a pre-trained text-to-image model on texts from text-only datasets. We use the Visual Genome Regions dataset (Krishna et al., ), which consists of 5.4M images with region descriptions. We also leverage Laion-220K (Schuhmann and Bevan, ), which comprises 220K captioned images from the LVIS dataset (Gupta et al., ), and Wikitext-103-raw-v1 (Merity et al., ), a collection of over 100 million tokens extracted from verified Wikipedia articles. To simulate inference with generated images, we randomly sample 2% of data from the Wikipedia textual dataset and use it to generate the corresponding image.

### 4.2 Implementation Details

Model optimization was performed using four A100 GPUs following a dual training pipeline. Initially, we trained the model for 40K iterations with a batch size of 256, employing the AdamW optimizer at a learning rate of $5\times 10^{-4}$ and utilizing a constant learning rate scheduler. Subsequently, the model was fine-tuned for an additional 10K iterations with a batch size of 128 and a learning rate of $5\times 10^{-5}$, again using a constant learning rate scheduler. We set $d_{\text{VTP}}=d_{x}$ and $\sigma$ (i.e., the non-linear activation function) to be GeLU (Hendrycks and Gimpel, ).

**Table 1: Results for zero-shot object commonsense tasks (i.e., Memory Color, Color Terms, Object Shape, and Relative Size). Results are reported for two main setups: (i). Masked Language Models, in which case vLMIG is based on the base BERT model, and (ii). Causal Language Models, in which case vLMIG is based on the base GPT-2 model.**
|  |  | Tasks |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Model | Base Model | Memory Color | Color Terms | Object Shape | Relative Size |
| BERT | - | 31.6 | 30.7 | 28.1 | 38.1 |
| Vokenization | BERT | 14.2 | 20.0 | 43.2 | 48.3 |
| X-adapter | RoBERTa | 59.6 | 53.8 | - | - |
| X-adapter | BERT | 64.1 | 60.0 | - | - |
| vLMIG | BERT | 74.5 | 72.5 | 67.3 | 78.4 |
| GPT-2 | - | 32.4 | 34.6 | 44.5 | 43.1 |
| Z-LaVI | GPT-neo-1.3B | 50.4 | 49.2 | 64.3 | 56.2 |
| LIVE | T5 | 42.4 | 41.5 | 36.4 | 70.1 |
| LIVE | BART | 49.6 | 46.7 | 41.5 | 66.7 |
| iNLG | BART | 48.6 | 44.8 | 39.5 | 51.1 |
| VaLM ($k=4$) | GPT-2 | 54.0 | 52.7 | 62.8 | 85.0 |
| VaLM ($k=8$) | GPT-2 | 58.6 | 50.2 | 59.4 | 62.4 |
| vLMIG | GPT-2 | 72.5 | 69.2 | 66.8 | 85.5 |

### 4.3 Evaluation Benchmarks

Object Commonsense (Object Color, Shape, and Relative Size).  For object commonsense evaluation, we employ the zero-shot evaluation benchmark proposed by Wang et al. (). This benchmark focuses on question-answering tasks related to colors, shapes, and sizes of objects. For color evaluation, we adapt the Memory Color (Norlund et al., ) and Color Terms (Bruni et al., ) datasets, and for shape assessment, we use the ViComTe shape dataset (Zhang et al., ). Size evaluation employs the dataset inspired by Bagherinezhad et al. (). All these tests adhere to the guidelines provided by Wang et al. ().

Visual Commonsense.  We evaluate the proposed method on ImageNetVC (Xia et al., ), a human-annotated dataset designed specifically for zero and few-shot visual commonsense evaluation across 1,000 ImageNet categories (Deng et al., ). It comprises more than 4,076 high-quality QA pairs over diverse domains such as color, shape, material, component, and general questions.

Commonsense Reasoning.  For commonsense reasoning, we consider the same benchmark tests from Touvron et al. (): PIQA (Bisk et al., ), SIQA (Sap et al., ), HellaSwag (Zellers et al., ), WinoGrande (Sakaguchi et al., ), ARC in both its easy and challenge forms (Clark et al., ), OpenBookQA (Mihaylov et al., ), and CommonsenseQA (Talmor et al., ). To gauge accuracy across these various tests, we utilize the metric proposed by Shwartz et al. ().

Reading Comprehension.  For reading comprehension, we adhere to the benchmark of Touvron et al. () and assess performance on BoolQ (Clark et al., ), SQuAD 2.0 (Rajpurkar et al., ), and QuAC (Choi et al., ). We evaluate SQuAD and QuAC using the settings recommended by Ouyang et al. () and report the exact match (EM) score. For BoolQ, we consider a zero-shot binary setup by selecting the highest probability between the yes and no tokens.

### 4.4 Baselines.

We consider two sets of baseline methods. To evaluate object color, shape, and relative size, we compared our method with visually augmented language models. Specifically, we considered Vokenization (Tan and Bansal, ), based on the based model of BERT,
X-adapter (Zhang et al., ) based on both the base model of BERT (Devlin et al., ) and RoBERTa (Liu et al., ), Z-LaVI based on GPT-neo-1.3B (Gao et al., ) iNLG using the version pretrained on COCO based on the base model of BART (Lewis et al., ), LIVE (Tang et al., ) on both the base model of BART and the base model of T5 (Raffel et al., ), and VaLM (Wang et al., ). We also directly compared these models to the base model of BERT and GPT-2 (Radford et al., ). To assess visual commonsense, commonsense reasoning, and reading comprehension, we conducted evaluations across a range of model sizes and architectures, including the base model of GPT-2, OPT-2.7B (Zhang et al., ), Gemma-2B (Team et al., ), and Llama3-8B (AI@Meta, ). Furthermore, we compared our method with a version of BLIP-2 (Li et al., ) built on top of the OPT-2.7B model, which excels in various multimodal tasks such as visual question answering, image-text retrieval, and image captioning.

## 5 Results

### 5.1 Main Results

Object Commonsense (Object Color, Shape, and Relative Size).
We start by reporting results on object commonsense tasks, which involve reasoning over the properties of objects. We report the results of vLMIG, considering either the GPT-2 and BERT models as the base pre-trained LLM. For a fair comparison, we restricted the training of our method to the Visual Genome dataset Krishna et al. (). For GPT-2-based models, we measured accuracy using direct zero-shot predictions. For BERT-based models, we adopted the approach from Zhang et al. (), which involves masking the sequence immediately after the last word and then revealing it for prediction.

In the Relative Size test, which involves a binary decision (yes/no questions), the GPT-2, BERT, LIVE, and iNLG models demonstrated a strong bias toward either "yes" or "no." To address this issue, we fine-tuned the models using the proposed method with 3,200 yes/no questions about object sizes from the ViComTe size dataset (Zhang et al., ), over three epochs and a learning rate of $5e^{-5}$.

Table 1 summarizes the results (^1^11The reported results of GPT-2, BERT, Z-LaVI, iNLG, and LIVE (Tang et al., ) were obtained by running the official codebase, while the results for the other models were taken from their respective papers. For the X-adapter, as no codebase exists, we could not obtain a result for Object Shape and Relative Size.). When considering BERT-based models, the proposed method provides significant improvements across all tasks and model variations. As for GPT-2, vLMIG significantly outperforms both the base model and VaLM across all setups, with minor improvement when considering Relative Size (85.0 vs. 85.5).

**Table 2: Results for visual commonsense, commonsense reasoning, and reading comprehension. We report results for the GPT-2 base model, Gemma-2B, OPT-2.7B, BLIP-2, and Llama3-8B. For fair comparison, the proposed method is based on the base LLM model at each table block.**
|  |  | Tasks |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Model | Base Model | Visual<br>Commonsense | Commonsense<br>Reasoning | Reading<br>Comprehension | Avg. |
| *Small-Scale Models* |  |  |  |  |  |
| GPT-2 | - | 30.3 | 46.1 | 30.5 | 35.6 |
| vLMIG | GPT-2 | 38.6 | 46.7 | 32.2 | 39.2 |
| *Mid-Scale Models* |  |  |  |  |  |
| Gemma-2B | - | 45.6 | 63.8 | 48.8 | 52.7 |
| vLMIG | Gemma-2B | 50.1 | 65.1 | 48.9 | 54.7 |
| OPT-2.7B | - | 41.0 | 50.9 | 44.6 | 45.5 |
| BLIP-2 | OPT-2.7B | 46.0 | 46.9 | 38.9 | 43.9 |
| vLMIG | OPT-2.7B | 45.4 | 51.6 | 44.7 | 47.2 |
| *Large-Scale Models* |  |  |  |  |  |
| Llama3-8B | - | 52.0 | 72.0 | 57.9 | 60.6 |
| vLMIG | Llama3-8B | 55.0 | 72.9 | 58.0 | 62.0 |

Visual Commonsense, Commonsense Reasoning, and Reading Comprehension. Next, we evaluate vLMIG on visual commonsense, commonsense reasoning, and reading comprehension. Results are reported in Table 2, and the results per subtask can be found in Section B.2. When considering visual commonsense, the proposed method is superior to the evaluated baselines across both small, mid, and large-scale models. Interestingly, the proposed method was also found to slightly improve model performance for commonsense reasoning and reading comprehension, which are more text-oriented evaluations that typically do not require visual reasoning. We improve $\sim$1 absolute points over both Llama-8B and Gemma-2B considering commonsense reasoning, with a comparable performance for reading comprehension.

When considering OPT-2.7B and BLIP-2 (a VLM based on OPT-2.7B), we found that although BLIP-2 improves performance on visual commonsense tasks (46.0 vs. 41.0), it comes at the expense of performance degradation on commonsense reasoning and reading comprehension, compared to the backbone of the method OPT-2.7B (46.9 vs. 50.9) and (38.9 vs. 44.6), respectively. This is in contrast to our method, which not only does not hurt performance but also provides minor improvements.

### 5.2 Ablation Studies

We present three main ablation studies: (i) analyzing the effect of the number of generated images on model performance; (ii) analyzing the effect of late vs. early fusion layers; and (iii) analyzing the effect of using multi-modal representation. Additional results and ablations can be found in Section B.1.

Figure: Figure 3: Average impact of the number of generated images per inference on performance, aggregating results from three tests: Color (Xia et al., ), PIQA (Bisk et al., ), and BoolQ (Clark et al., ). This graph displays the average performance scores for values of $k$ from 1 to 10, illustrating the general trend across varied test scenarios under identical settings.
Refer to caption: x3.png

The effect of $k$ (number of generated images). We analyze the impact of the number of generated images ($k$) during inference. We examined our method across various values of $k$, from $k=1$ to $k=10$. Due to resource constraints, we consider a single test from each of the three benchmarks (i.e., visual commonsense, commonsense reasoning, and reading comprehension). Specifically, we utilized the color test from the ImageNetVC benchmark (Xia et al., ) for visual commonsense.
For commonsense reasoning, we use the PIQA benchmark (Bisk et al., ), and for reading comprehension, we consider BoolQ (Clark et al., ).
Each test was performed under the same settings as in Section 4. The average results are shown in Figure 3, and the results per benchmark can be found in Table 12 on Section B.2.
As expected, we observe an improved performance as we increase $k$, with a performance saturation when generating $\sim 6$ images.

Late vs. early fusion of visual information. Visual information can be fused into LLMs in different ways. We consider the effect of fusing, or injecting, visual information in different stages on downstream task performance. We report the results of vLMIG when considering either early or late fusion.
In the case of early fusion, we apply our fusion layer to our visual pseudo tokens and textual tokens, which are the output of a single encoding layer of the pretrained LLM. We then pass the resulting output to the rest of the pretrained LLM.
We additionally provide a comparison for an alternative design choice, in which we omit the fusion layer and only optimize the vision projector layer while prepending such representation to the text input, which is then fed into the LLM. Other training configurations, such as the loss function, remain unchanged. We denote this method, *Prepend Fusion*.

**Table 3: Late vs. early fusion of visual information. Comparative performance of our model, early fusion, and prepend fusion across three benchmark tasks: Color Xia et al. (), PIQA Bisk et al. (), and BoolQ Clark et al. ().**
| Arcitrcture | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| Early fusion | 41.9 | 75.2 | 65.9 |
| Prepend fusion | 42.4 | 70.1 | 65.4 |
| Late fusion | 45.4 | 77.7 | 67.0 |

We provide results on the same tasks and datasets as the previous ablation. The results are presented in Table 3. Results suggest that late fusion provides the best results across all benchmarks.

CLIP text embedding vs. image generation. One might argue that multi-modal representations, which might serve as a bridge between image and text modalities, could be used instead to inject visual information. For instance, one could extract a CLIP representation for each input prompt and obtain a visually driven text representation. Such representation could be later used under the same modeling setup instead of synthetic image generation. And so the natural question is, *do synthetically generated images hold more information than multi-modal text representation?*

**Table 4: Performance comparison of image generation vs. CLIP text embedding approaches on Color (Xia et al., ), PIQA (Bisk et al., ), and BoolQ (Clark et al., ).**
| Method | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| Text Embedding | 38.9 | 77.6 | 66.5 |
| Generated Images | 45.4 | 77.7 | 67.0 |

To address this, we compare the proposed method against text representations obtained from a pre-trained CLIP (Radford et al., ) model. For a fair comparison, we adapt the proposed model architecture, datasets, and implementation details and only replace the visual representations with multi-modal textual representations. Initially, we tried to embed the full-text prompt using CLIP; however, this resulted in poor performance. Instead, as suggested by Guo et al. (), we extract noun entities from the text prompt using a part-of-speech tagger. Then, we embed this pre-processed text using CLIP text encoder. We report the Color test, PIQA, and BoolQ results under the same settings described in Section 4. Results are reported in Table 4. When considering visual commonsense (i.e., Color type benchmark), image generation significantly boosts performance. On PIQA and BoolQ, following the image generation approach resulted in a smaller improvement over the multi-modal alternative.

## 6 Discussion

Limitations
The main limitation of the proposed method is its inference run-time. Running inference with the proposed approach requires running the input prompt through a diffusion model to generate $k$ different images. Although recent diffusion models can generate high-quality images in a single step, this still results in non-negligible latency during inference. In cases where inference time is a crucial constraint, one could replace generated images with multimodal representations under the same framework. This results in a poorer performance compared to fully generating images (see Table 4), but runs faster ($\sim$500 ms in comparison to $\sim$1600 for vLMIG).

Conclusion
In this work, we introduce vLMIG, a method designed to enhance the visual commonsense capabilities of Large Language Models (LLMs) while maintaining their foundational text-based language reasoning capabilities. To allow this, vLMIG introduces two main novel components: (i). A novel training pipeline consisting of a late fusion layer applied over the output of a text-only LLM and visually adapted pseudo-textual tokens, and (ii). The integration of multiple visual “experts" through the generation of multiple images from a text-to-image model and the aggregation of their “vote" (or vector probabilities) enables the model to leverage diverse visual perspectives. We perform an extensive evaluation showcasing the applicability of our approach across a range of visual commonsense reasoning tasks, such as detecting an object’s color, shape, and size, demonstrating its significant superiority over existing baselines. Notably, vLMIG not only excels in visual tasks but also maintains, or even slightly improves, performance in non-visual tasks such as commonsense reasoning and reading comprehension, as evidenced by our evaluations on established benchmarks. For future work, we aim to explore the potential of vLMIG in more complex visual reasoning tasks, such as those involving intricate relationships between objects or requiring a deeper understanding of visual context.

## Appendix A Broader Impact

The broader impact of our method has both potential risks and benefits associated with the use of LLMs, visual encoders and text-to-image generators. As our method uses these components, it inherits their associated issues. The following are points that should be considered:

- •
Malicious input. This can be both at the text-to-image model, generating harmful content, which can be used by the model, as well as the use of the LLM itself that gets input text as input.
- •
Hallucinations. Similar to LLMs, our model might generate outputs that are not grounded in facts.
In our case, this can also happen at the text-to-image model, where the model generates factually incorrect visuals.
- •
Biases.
Biases can be performed both using the pre-trained LLM, the CLIP encoder, and text-to-image generator and transfer into our model. This may lead to biased output or to unfair representations of diverse content.
- •
Engergy consumptions. While our model primarily uses pretrained foundation models as part of our model design, and only adapts a lightweight vision projector fusion layer, trainig such pretrained models requires significant energy consumption. Further, inference time queries, performed many times may be costly.

We note that for each of these risk factors, significant research is devoted to mitigating them. In conjunction with this research, our work enables significant advances in improving visual commonsense in LLMs that can benefit the community.

## Appendix B Additional Results

**Table 5: Performance comparison of our method vs. Gemma-2B fine-tuned (FT) LLM on the Color [Xia et al., ], PIQA [Bisk et al., ], and BoolQ [Clark et al., ].**
| Method | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| Gemma-2B (FT) | 35.2 | 76.1 | 64.9 |
| vLMIG | 45.4 | 77.7 | 67.0 |

### B.1 Additional Ablations

vLMIG effectiveness vs. fine-tuned LLM.
To directly assess the impact of image integration, we compare our approach with a baseline using Gemma-2B [Team et al., ], which was fine-tuned on the same datasets but without visual elements. The Gemma-2B model was fine-tuned with a learning rate of $5e-5$, identical to our training settings but excluding the additional visual layers. Results on the Color test from ImageNetVC [Xia et al., ], PIQA [Bisk et al., ], and BoolQ [Clark et al., ], detailed in Table 5, demonstrate that including images significantly enhances performance across all benchmarks, highlighting the benefits of multimodal data integration.

**Table 6: Experiment results using different visual encoders on Color [Xia et al., ], PIQA [Bisk et al., ], and BoolQ [Clark et al., ].**
| Visual encoder | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| DINOv2 | 43.9 | 77.0 | 66.6 |
| CLIP | 45.4 | 77.7 | 67.0 |

The effect of the visual encoder.
Our model employs the CLIP [Radford et al., ] visual encoder to handle image features, leveraging its multimodal training with text. We evaluate its effectiveness against a unimodal image encoder, DINOv2 [Oquab et al., ], across the same tasks: the Color test, PIQA, and BoolQ. Results are summarized in Table 6. Although DINOv2 provides comparable or superior performance to the baseline methods, results suggest that CLIP still outperforms DINOv2, particularly in tasks requiring nuanced visual comprehension, validating our choice of CLIP for enhanced multimodal learning.

The effect of the image generation model.
To explore the impact of image fidelity on reasoning capabilities, we evaluate two text-to-image models: SDXL-turbo and SD-turbo. These experiments were conducted on the same tasks and datasets as the previous ablation. As shown in Table 7, SDXL-turbo significantly outperforms SD-turbo in the Color task, indicating that superior image quality directly contributes to better performance in visual commonsense reasoning. While improvements in PIQA and BoolQ are less pronounced, they underscore the importance of high-quality image generation in our model. These results imply that advancements in text-to-image research will additionally improve our method.

**Table 7: Experiment results using different text-to-image models on Color [Xia et al., ], PIQA [Bisk et al., ], and BoolQ [Clark et al., ].**
| T2I model | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| SD-turbo | 41.9 | 76.9 | 66.7 |
| SDXL-turbo | 45.4 | 77.7 | 67.0 |

Generated images test prompts strategy.
To determine the most effective image generation strategy for enhancing our model’s interpretative and reasoning capabilities, we compared three methods: generating images from the last sentence, the entire textual context, and the latest $k$ sentences. These strategies were evaluated across the same benchmarks: the Color task from ImageNetVC, PIQA, and BoolQ. Results, detailed in Table 8, show that generating images from the latest $k$ sentences consistently leads to the best performance in PIQA and BoolQ test, providing a dynamic and contextually relevant visual representation. In the Color test, since all the questions include a single sentence, the results are the same.

**Table 8: Experiment results comparing different image generation strategies on Color [Xia et al., ], PIQA [Bisk et al., ], and BoolQ [Clark et al., ].**
| Style | Color | PIQA | BoolQ |
| --- | --- | --- | --- |
| Last Sentence | 45.4 | 75.9 | 66.1 |
| Full Context | 45.4 | 76.6 | 66.4 |
| K Latest Sentences | 45.4 | 77.7 | 67.0 |

### B.2 Detailed Results

We present comprehensive results for all benchmarks discussed. First, results for the visual commonsense benchmark are detailed in Table 9. Second, results for commonsense reasoning are provided in Table 10, and third, results for reading comprehension are provided in Table 11.

Furthermore, Table 12 presents the complete results of our experiment investigating the impact of the number of images generated per inference on performance, as discussed in Figure 3.

**Table 9: Visual commonsense performance per subtask, corresponding to Tab. 2.**
|  |  | Tasks |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Model | Base Model | Color | Shape | Material | Component | Others | Avg. |
| Random | - | 7.7 | 9.9 | 6.1 | 49.8 | 24.3 | 19.4 |
| *Small-Scale Models* |  |  |  |  |  |  |  |
| GPT-2 | - | 17.1 | 21.8 | 27.1 | 50.4 | 35.1 | 30.3 |
| vLMIG (ours) | GPT-2 | 44.8 | 29.2 | 32.8 | 49.9 | 36.5 | 38.6 |
| *Mid-Scale Models* |  |  |  |  |  |  |  |
| Gemma-2B | - | 33.4 | 34.1 | 52.3 | 59.5 | 49.0 | 45.6 |
| vLMIG (ours) | Gemma-2B | 45.4 | 36.8 | 57.7 | 59.6 | 51.2 | 50.1 |
| Opt 2.7B | - | 25.7 | 39.9 | 40.2 | 51.3 | 48.1 | 41.0 |
| BLIP-2 | Opt 2.7B | 37.8 | 38.7 | 53.1 | 51.7 | 48.5 | 46.0 |
| vLMIG (ours) | Opt 2.7B | 35.5 | 40.8 | 48.5 | 51.9 | 50.2 | 45.4 |
| *Large-Scale Models* |  |  |  |  |  |  |  |
| Llama-8B | - | 40.2 | 39.6 | 57.6 | 67.8 | 55.0 | 52.0 |
| vLMIG (ours) | Llama-8B | 48.0 | 40.9 | 60.4 | 69.7 | 56.0 | 55.0 |

**Table 10: Commonsense reasoning performance per subtask, corresponding to Tab. 2.**
|  |  | Tasks |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Model | Base Model | PIQA | SIQA | HS | WG | ARC | OBQA | CQA | Avg. |
| *Small-Scale Models* |  |  |  |  |  |  |  |  |  |
| GPT-2 | - | 62.6 | 38.4 | 31.8 | 50.8 | 34.8 | 25.6 | 32.8 | 46.1 |
| vLMIG (ours) | GPT-2 | 62.2 | 38.9 | 31.9 | 51.5 | 33.7 | 27.4 | 34.0 | 46.7 |
| *Mid-Scale Models* |  |  |  |  |  |  |  |  |  |
| Gemma-2B | - | 77.0 | 42.1 | 66.6 | 62.2 | 47.7 | 40.2 | 46.8 | 63.8 |
| vLMIG (ours) | Gemma-2B | 77.7 | 44.0 | 67.0 | 62.5 | 49.1 | 40.3 | 50.6 | 65.1 |
| OPT-2.7B | - | 73.4 | 42.4 | 55.2 | 57.3 | 47.0 | 34.8 | 46.5 | 50.9 |
| BLIP-2 | OPT-2.7B | 68.8 | 40.0 | 54.2 | 53.8 | 40.3 | 33.0 | 38.8 | 46.9 |
| vLMIG (ours) | OPT-2.7B | 73.8 | 43.8 | 55.0 | 57.2 | 48.5 | 34.3 | 49.1 | 51.6 |
| *Large-Scale Models* |  |  |  |  |  |  |  |  |  |
| Llama-8B | - | 80.3 | 46.1 | 77.1 | 71.0 | 60.0 | 44.6 | 54.8 | 72.0 |
| vLMIG (ours) | Llama-8B | 81.4 | 46.6 | 76.5 | 70.8 | 59.8 | 46.0 | 56.3 | 72.9 |

**Table 11: Reading comprehension performance per subtask, corresponding to Tab. 2.**
|  |  | Tasks |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Model | Base Model | Boolq | SQuAD | QuAC | Avg. |
| *Small-Scale Models* |  |  |  |  |  |
| GPT-2 | - | 47.7 | 27.4 | 16.6 | 30.5 |
| vLMIG (ours) | GPT-2 | 48.7 | 29.3 | 18.8 | 32.2 |
| *Mid-Scale Models* |  |  |  |  |  |
| Gemma-2B | - | 66.8 | 57.4 | 22.4 | 48.8 |
| vLMIG (ours) | Gemma-2B | 67.0 | 57.3 | 22.4 | 48.9 |
| Opt 2.7B | - | 63.1 | 50.5 | 20.4 | 44.6 |
| BLIP-2 | Opt 2.7B | 59.9 | 40.4 | 16.5 | 38.9 |
| vLMIG (ours) | Opt 2.7B | 63.0 | 51.5 | 19.8 | 44.7 |
| *Large-Scale Models* |  |  |  |  |  |
| Llama-8B | - | 79.3 | 69.2 | 29.1 | 57.9 |
| vLMIG (ours) | Llama-8B | 79.0 | 69.1 | 29.3 | 58.0 |

**Table 12: Impact of the number of generated images per inference on performance per task, corresponding to Figure 3.**
|  | Tasks |  |  |  |
| --- | --- | --- | --- | --- |
| Number of Images | Color | PIQA | BoolQ | Avg. |
| 1 | 40.8 | 76.1 | 66.1 | 60.3 |
| 2 | 41.8 | 76.7 | 66.4 | 61.2 |
| 3 | 42.6 | 77.1 | 66.5 | 62.0 |
| 4 | 43.5 | 76.9 | 66.6 | 62.3 |
| 5 | 43.8 | 77.3 | 66.8 | 62.6 |
| 6 | 45.1 | 77.6 | 66.6 | 63.1 |
| 7 | 44.8 | 77.4 | 66.8 | 63.1 |
| 8 | 45.4 | 77.7 | 67.0 | 63.3 |
| 9 | 45.2 | 77.7 | 66.8 | 63.2 |
| 10 | 45.4 | 77.7 | 67.0 | 63.3 |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: As weakness
soundness: 3
strengths: VLMIG’s late-fusion approach, which combines textual and visual data just before final prediction, allows it to perform well on both visual and textual commonsense tasks. This ensures that LLMs benefit from visual grounding while retaining their core language abilities. The model excels across multiple task types, including object commonsense tasks (e.g., color and shape recognition) and reading comprehension. This versatility makes it a well-rounded approach for both visual and language-based tasks. VLMIG consistently outperforms existing models, including VLMs and VaLMs, in visual commonsense benchmarks, showing that multiple image generation and aggregation is a promising direction for enhancing multimodal reasoning capabilities. The authors conduct thorough experiments, including ablation studies, to validate the effects of different components, such as multi-image generation and the late-fusion layer. This helps substantiate the robustness and adaptability of the proposed model.
summary: The paper introduces a method called VLMIG, aimed at enhancing visual commonsense reasoning in large language models (LLMs) by incorporating multiple generated images into the inference process. The method is particularly innovative in its use of a late-fusion mechanism, allowing the language model to consider both text and visual information without compromising on text-based tasks. VLMIG integrates various image predictions generated by a pre-trained text-to-image model, weighting them to improve visual commonsense understanding. Experimental results demonstrate VLMIG’s effectiveness across several tasks, such as visual commonsense reasoning and traditional language benchmarks, outperforming current baselines and maintaining strong performance in non-visual tasks.
weaknesses: 1. The method relies heavily on the quality of generated images. Poor text-to-image generation could potentially harm performance, but this potential failure mode isn't thoroughly discussed. The effectiveness of VLMIG depends on the quality and relevance of the generated images. If the text-to-image model generates incorrect or low-quality images, this could lead to suboptimal or incorrect predictions, as the ensemble approach relies on the integration of various visual predictions
2. The approach requires generating and processing multiple images during inference, which likely increases computational costs and latency significantly. Although high-quality images can be generated quickly, this approach still results in considerable computational and time costs, especially when k is large. This could limit the method's practicality in time-sensitive applications
3. The paper doesn't adequately address how the approach scales with larger language models or longer text inputs, particularly given the computational requirements of processing multiple images.
4. There isn't sufficient analysis of the contribution of each component (VTP, LFAL, multiple image generation) to the overall performance.
5. Only test on VLMIG with GPT-2 backbone for table 1 may be really far away from current VLM community.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: For the different vLMIG models in Table 1 & 2, how many layers are used in the fusion module?
soundness: 3
strengths: The main strengths of the paper are as follows:

* The empirical studies are conducted on variety of models (BERT, GPT-2, Llama-8b, Gemma-2B) which is commendable and also shows the broader applicability of the method.

* The empirical improvements on the datasets presented in the paper are significant, especially at smaller scale models (BERT, GPT-2, Gemma-2B).

* The proposal method is simple and easy to integrate in any existing LLMs.
summary: This paper proposes a new method for Visually-augmented Language Models (VaLM). The method proposes using fixed (frozen) pre-trained LLM and visual encoders and trainable visual projection and multimodal fusion layers. The pre-trained components never see inputs from the other modality. The fusion layer feeds into the output (softmax) layer. A second contribution of the paper is to use multiple generated images at inference with weighted-average vectors. The method shows empirical improvement in visual understanding tasks while showing neutral-positive behavior on pure text-understanding tasks.

[Update after author rebuttal] Given authors' clear rebuttals with additional results, I have revised my rating from 6 --> 8.
weaknesses: The main weaknesses of the paper are:

* While the proposed method shows significant improvements in visual understanding tasks at small scale, the results at larger scale (namely Llama-8b in Table 2) show very marginal improvements over the baseline which suggests either (a) the late fusion network requires many more parameters (more # of transformer layers) as the base model becomes more capable, or (b) at larger base models, we need a more end-to-end approach where we feed concatenated text+image tokens at the input layer as opposed to the proposed late fusion approach.

* The visual understanding dataset used in Table 1 (object common sense) seems too simple to form a very informed opinion of the proposed method. The authors mention running this method on more complex datasets as future work but we may need to see some results during the discussion phase if possible.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. How many A100 hours are used for your training?

2. Why an out-of-date Wikitext-103 dataset is adopted as the training corpora, maybe ShreadPajama is another better choice? Or you adopt this dataset for the density of knowledge?
soundness: 3
strengths: 1. This work resolved a significant issue in current LLaVA-style MLLMs, in which the lightweight visual SFT always leads to significant catastrophic forgetting and performance degradation on text-only capabilities. VILA (Lin et al., 2023) resolved this via large-scale multimodal pre-training, while the efficient training pipeline for resolving this issue is not explored well. Concluding from the results in Table-2, LLaVA-Next also gets a 2.9 scores degradation compared with its LLM backbone vicuna-7b, while the vLMIG achieved a slightly +0.2 score improvement.
summary: This work proposed vLMIG, a novel visually-augmented language modeling framework for visual commonsense reasoning.
weaknesses: 1. This architecture design only slightly differs from Flamingo, in which Flamingo adopts the cross-attention and this work adopts joint self-attention following VaLM. An ablation study on adopting cross-attention layer design is also appreciated to investigate some potential in architectural design.

2. An ablation study on the number of LFALs can also strengthen the contribution of this work. Flamingo adds cross-attention to each layer, while vLMIG only adds one LFAL. If there is a scaling effect on the number of introduced LFALs, then the users can decide how many LFALs to add to achieve a great tradeoff between performance and efficiency.

3. A significant baseline of LLaVA-llama3-8b is missed. You can consider to try to eval the https://huggingface.co/lmms-lab/llama3-llava-next-8b model and add the results to Table 2.

4. The efficiency is still another concern due to the image generation at inference stage in Table 3. Maybe retrieval is a better way? Or some explorations on efficient image generation can be also added to this work.

---

confidence: 2
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. Are some paramaters frozen during training? The performance of vLMIG based on Llama3-8B is even improved on QuAC while only training on Visual Genome which exhibit limited text diversity.
2. Maintaining text understanding capability during training VLMs is studied comprehensively, such as MM1 and Deepseek-VL. I am curious if these VLMs can directly give good performance on tasks requiring visual commonsense knowledge while keeping a nice performance on textual tasks.
soundness: 2
strengths: 1. Performance improvements  on object commonsense tasks are significant compared with baseline VaLMs.
2. The proposed method is simple to implement and ablation studies is comprehensive.
summary: This paper propose a novel late-fusion method incorporating multiple images during training and inference to augment visual commonsense of LLMs. During inference, vLMIG leverage a Text2Image model to generate multiple images based on input text and use features of these image to enhance the KV in fusion layer upon the LLM.
weaknesses: 1. The reproducibility of results are questionable since the papers fails to clearly introduce the exact setting of the experimental results. For example, Sec. 4.1 states VG and Laion-220K are both used while #371 says only VG is used. 
2. The comparison setting might be unfair. How to decide whether an incoming question needs image to augment or not? For questions that are irrelevant to visual knowledge, generated images can possibly harm the performance. Specifically, does the model generated images during evaluation on datasets like SQuAD.

Meta-review: The paper proposes vLMIG, a method for enhancing visual commonsense reasoning in language models by generating and incorporating multiple images during inference via a late fusion mechanism. The late-fusion approach allows LLMs to leverage visual information while maintaining text understanding capabilities, addressing the catastrophic forgetting issue common in multimodal models; The use of multiple generated images with weighted averaging improves robustness, which also shows promising improvements over baselines on visual commonsense reasoning tasks.

However, the main weakness is the computational overhead from generating multiple images during inference, though the authors demonstrate ways to mitigate this through parallel processing and using fewer images. In addition, while the method shows strong results on smaller models, the improvements become more marginal with larger backbones, suggesting potential scaling limitations. Most concerns have been addressed during the rebuttal, but some reviewers still remain unconvinced.

Decision: Reject