LM4LV: A Frozen Large Language Model for Low-level Vision Tasks

## Abstract

Abstract The success of large language models (LLMs) has fostered a new research trend of multi-modality large language models (MLLMs), which changes the paradigm of various fields in computer vision. Though MLLMs have shown promising results in numerous high-level vision and vision-language tasks such as VQA and text-to-image, no works have demonstrated how low-level vision tasks can benefit from MLLMs. We find that most current MLLMs are blind to low-level features due to their design of vision modules, thus are inherently incapable for solving low-level vision tasks. In this work, we purpose LM4LV , a framework that enables a FROZEN LLM to solve a range of low-level vision tasks without any multi-modal data or prior. This showcases the LLM’s strong potential in low-level vision and bridges the gap between MLLMs and low-level vision tasks. We hope this work can inspire new perspectives on LLMs and deeper understanding of their mechanisms. Code is available at https://github.com/bytetriper/LM4LV .

## 1 Introduction

The great success and generalizability of Large Language Models (LLMs) have brought a new research trend of Multi-modality Large Language Models (MLLMs).
We wonder how much LLMs can benefit computer vision to achieve better performance and realize real intelligence. Recent attempts on MLLMs have demonstrated promising results on high-level vision tasks, such as image captioning and visual question answering (VQA).
Then we are curious about its capability on low-level vision tasks, like image denoising and deraining. On the other hand, since existing works [, ] have proved LLMs can already understand semantic image features, how far are they from directly generating images as a generative model? All of these converge to the same question: is it possible to utilize MLLMs to accept, process, and output low-level features? This is important to further push the limit of MLLMs and low-level vision. We will make a preliminary exploration in this work.

Existing literature shows a significant gap between MLLMs and low-level vision tasks.
The current major direction for many MLLM related works is towards a better semantic fusion of the text and image modality.
Following this trend, some works [, , ] purpose to use LLMs for evaluating low-level attributes such as lightness and sharpness. However, most low-level vision tasks process and generate pixel-level information, which does not correspond with meaningful words.
Moreover, the output images must have high fidelity and consistency with the original images, which is a common flaw of current MLLMs. Though many works [, , , , , , , ] put effort in empowering MLLMs with image generation capability, most of these MLLMs lack detailed control of the image. In Sec. 3.1, we show that most MLLMs with image generation capabilities fail to perform simple image reconstruction. This indicates that these MLLMs are inherently not capable of handling low-level vision tasks, as they lack the ability to process low-level details.

Bridging the gap between MLLMs and low-level vision tasks is important for both fields. MLLMs have shifted the paradigm in many fields of computer vision by unifying vision tasks into a general conversational manner. However, low-level vision tasks have not yet benefited significantly from the changes brought by MLLMs. Currently, most low-level vision modules [, , ] simply offer an image-to-image mapping without text interventions. Bridging this gap could allow us to leverage the strong reasoning and text generation abilities of MLLMs for low-level vision tasks, providing better user interaction and greater interpretability in solving low-level vision tasks. On the other hand, low-level features are important components of images, but are often overlooked and discarded in current MLLMs. Enabling MLLMs to process low-level features can lead to a more fine-grained understanding of images and better control in the process of image generation.

Moreover, the majority of MLLMs are trained on a massive corpus of multimodal data, with an existing LLM as initialization. However, it is underinvestigated what the LLM initialization brings to the MLLM. Does the LLM simply offer strong capabilities for text, or does it also provide underlying abilities for other modalities as well? Therefore, we highlight the importance of investigating LLMs’ capability to process visual features with no multi-modal data or prior, which can lead to a deeper understanding of LLMs’ inner mechanisms. Although a series of works [, , , ] have put efforts into investigating the visual feature processing ability of a frozen LLM, none of them have succeeded in enabling the LLM to produce visual features without multi-modal supervision. LQAE [] managed to perform image-to-text tasks in an in-context learning (ICL) manner without any multi-modal data by quantizing images into text tokens. However, it fails even for very basic low-level vision tasks such as deblurring, demonstrating its inability for conditional image generation.

In this work, we make the first attempt to investigate a frozen LLM’s capability in processing low-level feature, proving that a frozen LLM can accept, process and auto-regressively output visual features without any multi-modal data or prior. By simply training two linear layers with vision-only data,
a frozen LLM showcases non-trivial capability on a wide range of low-level vision tasks.

## 2 Related Works

### 2.1 Multi-modal Generation with LLMs

Many attempts have been made to equip LLM with multi-modal generation ability. We categorize these attempts into two types: those that require an additional text-to-image module and those that do not. The vast majority of research falls into the former category, such as DreamLLM [] and KosMOS-G [], which necessitate the integration of an external text-to-image module pre-trained extensively on multi-modal documents, such as Stable Diffusion []. In these instances, the LLM backbone is responsible for producing textual vectors that serve as the text condition in the text-to-image module, while the actual conversion from text to image is carried out by a powerful external module. A significant downside of using overly powerful external text-to-image modules is their inability to facilitate precise image control, rendering tasks such as image segmentation and image restoration infeasible. To enhance the precision of image control, some studies purpose to add skip-connections from the encoder. PixelLLM [] employs a lightweight, pixel-level decoder with skip-connection from encoder to perform language-interactive image segmentation tasks. SEED-X [] applies a similar approach by skip-connecting the original image to the decoder as a reference for conditional image generation. Though those approaches have shown more precise image control, the skip-connection raises questions about the role of LLM in the process.

For the latter category, a common architecture is to use a VQGAN [] to patch images into tokens. Therefore, the training objective can be unified as next-token prediction. A number of works [, , , ] have shown the success of this approach. However, all those model train the whole backbone (either from scratch or from a existing LLM) on massive multi-modal data. As a result, the final backbone largely differs from a LLM, failing to provide a clear understanding of the capability of a LLM in processing visual features. Therefore, we will not discuss MLLMs of this type in this work. From this point forward, we will refer MLLM as the first type of MLLM.

### 2.2 Frozen LLM for Tasks of Other Modalities

In contrast to the above-mentioned works that requires heaving LLM backbone training, some works [, , , ] have shown that a pre-trained LLM without further training can be used to perform tasks of other modalities. For example, LimBER [] shows that training a simple linear layer between a unsupervised trained vision encoder and a frozen LLM on multi-modal data empowers the LLM with visual understanding ability. LQAE [] further shows the possibility of image-text aligning without multi-modal data. By training a VQGAN that quantize image to text tokens. LQAE showcases that the LLM is able to classify image in a in-context-learning (ICL) manner. However, none of them have succeed to extend the LLM’s capability to generating images. As an improvement to LQAE, SPAE [] apply a similar image-to-text-token quantizing strategy, but introduce CLIP [] as a cross-modal supervision in VQGAN training. SPAE is able to encode images directly into semantic-related text tokens, enabling the LLM for conditional image generation in a ICL manner. So far, SPAE-like methods has been the only successful approach to enable a frozen LLM for conditional image generation. However, SPAE still requires a multi-modal prior (CLIP), and directly encodes images to semantic-related text tokens. This raise questions about whether LLM is processing visual features or simply text features. In this work, we show that it’s possible to empower LLM with conditional image generation ability without any multi-modal data or prior. This indicates that LLM is able to understand, process and output visual features even under no image-text alignment.

Figure: Figure 1: Reconstruction results of the vision modules in different MLLMs. Emu2 provides highly semantic consistent images but fails to maintain low-level details, while MAE can reconstruct images with precise low-level details.
Refer to caption: x1.png

## 3 Method

### 3.1 Current MLLMs are BLIND to Low-level Features

Our inspiration stems from an observation: current MLLMs [, , , , , , , ] with image generation ability are blind to low-level visual features. Therefore, they are inherently incapable of handling low-level vision tasks.
We attribute the blindness of MLLMs to their vision modules. We have observed that most MLLMs’ vision modules could not perform image reconstruction, indicating that the vision encoders in the vision modules are performing a lossy encoding process.
As shown in Fig. 1, the vision module in MLLMs often tend to capture high-level semantics but fail to maintain low-level details, conducting a lossy compression of the image. More discussion and visualization can be found in Appendix A.1.

Currently, most MLLMs follow this lossy compression approach, often relying on large-scale multi-modal training to train their vision modules. For example, Emu2 [] uses 162M image-text pairs to train a vision encoder along with the LLM backbone and utilizes a pre-trained text-to-image diffusion model [] as the decoder. The advantage of this approach is evident: extensive multi-modal training results in better alignment between vision and text. A better alignment often brings an improved interaction and fusion of modalities, which is important for an MLLM. This also allows these MLLMs to use pre-trained LLMs as the backbone initialization for further training. For instance, SEED [] empowers a LLM with image generation ability by fine-tuning the LLM using LoRA. However, the downside of this alignment is that the visual features often lose much of the original image information, failing to maintain low-level details. Therefore, we argue that these MLLMs inherently lack the ability to handle low-level tasks.

### 3.2 Enable LLM to See Low-level Features

Principles for Choosing Vision Modules.
As discussed in Sec. 3.1, current choices of vision modules in MLLMs fail to maintain low-level details. Therefore, choosing a suitable vision module that contain full information of the image is crucial. This allows the LLM backbone to have access to low-level features, which is the basis for further exploration of the LLM’s capability in processing low-level features.
We argue that two principles are essential for selecting vision modules. First, the training objective of the vision module should be reconstruction. This encourages the vision encoder to maintain low-level details so the encoded feature can be decoded back to pixel space. Second, the vision modules must be trained in an unsupervised manner to avoid any multi-modal training.
This is important because the LLM already possesses strong text processing capabilities. If the encoder has already transformed the image into text-like features, it becomes unclear whether the LLM is leveraging its powerful text processing abilities to handle text features or it inherently has the capability to process other modalities.
Under these constraints, only several families of visual encoder remains. Among them, our final choice is the Masked Autoencoder (MAE) [], a representative of the Masked Image Modeling (MIM) family, which encodes an image to a sequence of visual features and aims to reconstruct the original image using masked image tokens. We discuss more choices of the vision module in Sec. 4.3.

Figure: Figure 2: Network structure of our design. In the training phase, the visual tokens and the task tokens learns to prompt the LLM to generate next visual/text tokens. In the inference phase, the LLM generates visual tokens and text tokens in an auto-regressive manner. The visual tokens are then decoded into images.
Refer to caption: x2.png

Fine-tuning MAE for Image Reconstruction.
Though MAE is trained to reconstruct images from a masked token sequence, using MAE directly for image reconstruction will result in poor performance.
We identify that this issue arises primarily because the released version of MAE calculates the reconstruction loss solely on masked tokens. This leads to inconsistency between training and inference behaviors since there are no masked tokens during image reconstruction. We fine-tune the decoder of MAE on the ImageNet training set using an L1 reconstruction loss while keeping the encoder frozen. More details can be found in Appendix A.2.

This fine-tuning significantly improves MAE’s performance in image reconstruction. Following VQGAN [, ], we further incorporate the LPIPS loss [] into the training, leading to a better reconstruction FID but a slightly lower PSNR score.
Though [] shows that a per-patch adversarial loss may further improve performance, we do not incorporate the adversarial loss as this may bring artifacts into images [, ]. As our objective is to investigate the capability of LLMs in processing visual features, we expect the decoder to be faithful to these features, rather than introducing artifacts during the decoding process.

Table: Table 1: Reconstruction FID (rFID), precision, recall and PSNR on the validation set of ImageNet. MAE-L1 indicates to use L1 loss for fine-tuning MAE’s decoder. MAE* is the version tuned by a combination of L1 loss and LPIPS Loss. Best results are bolded.

| Model | rFID$\downarrow$ | prec(%)$\uparrow$ | recall(%)$\uparrow$ | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- |
| MAE | 84.22 | 13.35 | 45.78 | 19.15 |
| MAE-L1 | 9.96 | 88.46 | 97.57 | 29.21 |
| VQGAN | 1.49 | 94.90 | 99.67 | 22.61 |
| MAE* | 1.24 | 99.94 | 99.97 | 28.96 |

We compare MAE with a commonly used image reconstruction module VQGAN(^1^11We use a VQGAN from [https://github.com/CompVis/taming-transformers](https://github.com/CompVis/taming-transformers), trained on OpenImage with downsample rate 8 and a vocabulary of 16384) []. From Tab. 1 and Fig. 4, the fine-tuned MAE has the best reconstruction ability, introducing less artifacts and showing better face reconstruction. More training details can be seen in Appendix A.2.
From this point forward, unless specified otherwise, the term MAE refers to the fine-tuned version MAE*.

### 3.3 Next Element Prediction on Low-level Vision Tasks

Similar to Emu and Emu2 [, ], we apply a next element prediction strategy to enable LLMs to accept visual features and output visual features in an auto-regressive manner. Our main network structure is illustrated in Fig. 2.

Adapter Modules. As we want to investigate the LLM’s capability to process low-level vision features, we need to constrain the adapter’s complexity. Therefore, we use two simple linear layers as the adapter modules between the LLM and the vision encoder/decoder to align the feature dimension. We call the visual features "visual tokens" if they are aligned with the LLM’s dimension.

Training & Generation Scheme. In training, we apply the standard next-token cross-entropy loss for text tokens. For continuous visual tokens, we apply a next token $l_{2}$-regression loss. This unifies the training process for both text and visual as next-element prediction tasks. For generation, we use the auto-regressive generation scheme, generating one text or visual token at a time.
To switch between generating visual and text tokens, we set that text tokens are generated by default, and visual features are delineated by markers <Img> and </Img> before and after, respectively. Generation of a visual feature occurs only after the LLM has generated <Img>. After generating a sequence of visual tokens, the LLM returns to generating text tokens. The visual token sequence is then transformed to visual features through the linear adapter and decoded into an image by the visual decoder.

Under this paradigm, we define low-level vision tasks as conditional image generation tasks performed under visual instructions. For a pair consisting of a low-quality image and a high-quality image, we convert this into a conversation format:

$$ Human: <Img> <LQ-image> </Img> Assistant: <Img> <HQ-image> </Img> $$

Here <LQ-image> and <HQ-image> represent the visual feature sequences (after linear projection) for low and high quality images respectively. We apply an instruction-tuning strategy, similar to [], only calculating the loss for the desired output <Img><HQ-image></Img>.

However, the current design lacks a description of the target low-level vision tasks. This may lead to the inclusion of task-related soft prompts within the trained adapter projection, which is not desired as we expect the adapter module to purely focus on the translation between image and text space. Since low-level vision tasks are challenging to be described precisely using language, we incorporate a trainable task token sequence <task> within the instructions. This serves as a soft prompt to guide the LLM in performing specific low-level vision tasks. The final data format is as follows:

$$ Human: <Img> <LQ-image> </Img> <task> Assistant: <Img> <HQ-image> </Img> $$

In this format, normal text tokens (marked in black) is tokenized normally. The visual tokens (marked in blue) are encoded by a vision encoder and a linear layer. The task token (marked in red) is a trainable embedding sequence that is directly inserted into the input sequence.
Within the entire pipeline, the only trainable parameters are the two linear adaptation modules and the task token sequence, which are jointly optimized during training.

## 4 LLM’s Capability on Low-level Tasks

### 4.1 Experiment Setup

Base Models & Hyperparameters. We use LLaMA2-7B instruct(^2^22https://llama.meta.com/llama2/) [] as the base LLM for all our experiments. For vision modules, we use MAE-Large(^3^33https://huggingface.co/facebook/vit-mae-large) [] and fine-tune the decoder as mentioned in Sec. 3.2. For adaptation modules, we only use linear layers as an affine transformation. We use a trainable task token sequence of length 10 by default.

Training Details. We use the LLAVA595k(^4^44https://huggingface.co/datasets/liuhaotian/LLaVA-CC3M-Pretrain-595K) [] dataset as our base dataset for degradation generation without data augmentation. All images are resized to $224\times 224$ to fit the input size of MAE.
We use an actual batchsize of $256$. By default we train the model for 2 epochs as we observe convergence after 2 epochs. We use AdamW as the optimizer, with $\beta=(0.9,0.95),lr=3\times 10^{-4}$ and no weight decay. We use warm-up decay strategy with 200 warm-up steps. All experiments are done on a maximum of 4 NVIDIA A100 GPUs. A single training takes around 8 hours.

Evaluation tasks. We evaluate our method on several representative low-level vision tasks: denoising [, , ], deblurring [, ], pepper noise removal [, ], deraining [, , ] and mask removal [, ]. We use the NoCaps dataset(^5^55https://huggingface.co/datasets/HuggingFaceM4/NoCaps) as the test set and add the same degradations as training. We use PSNR and SSIM as our default metrics. Additionally, SPAE [] shows that a simply rotation could be challenging under a similar setup. Thus we set two simple tasks that requires large spatial operation: image rotation and image flipping. We name the tasks as restoration tasks and spatial operation tasks respectively.

Degradation details. For denoising, We add Gaussian noise with zero mean and a random standard variance uniformly sampled from $[0,50/255]$. For deblurring, we add Gaussian blur to the images with a window size uniformly sampled from $\{1,3,5,7\}$. For deraining, we add rains at random angles and positions to the images with an amount uniformly sampled from $[0,20]$. For pepper noise removal, we set the portion of peppers in the degraded images to be uniformly sampled from $[0,0.1]$. For mask removal, we use a mask size of $4$ and a masking rate of $0.1$.

Baselines. As our goal is to investigate whether LLM has the ability to process low-level features and handle low-level vision tasks, we only need to verify that using LLM is better than doing nothing. Thus we set a baseline of using MAE to reconstruct degraded images without further modification (denote as MAE-r). In restoration tasks, this baseline serves as a lower-bound for MAE-based image restoration methods. In spatial operation tasks, this baseline serves as the upper-bound, as the degraded images in this case is the operated images.

### 4.2 LLM Shows Non-trivial Capability on Low-level Vision Tasks

Our main results are shown in Tab. 2, with some visualizations presented in Fig. 3. From Tab.2, LM4LV stably obtains a higher PSNR and SSIM score than the MAE-r baseline among all restoration tasks. Under image denoising task, LM4LV achieves a higher PSNR score with an increase of 6.81dB (from 19.96dB to 26.77dB). On all restoration tasks, LM4LV achieves an average PSNR score increase of 3.96dB, an average of SSIM increase of 0.09. On spatial operation tasks, LM4LV achieves high PSNR and SSIM, enclosing the margin to the upper-bound baseline. The results indicates that LLM has non-trivial capability in processing and outputting raw visual features. We give more visualizations and failure cases in Appendix C.1 and Appendix C.2.

**Table 2: Results of LM4LV on various low-level vision tasks. The top five tasks are image restoration tasks, the bottom two tasks do not require restoration, but involve large-scale spatial operations.**
| Tasks | Degraded | MAE-r | LM4LV |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| PSNR $\uparrow$ | SSIM $\uparrow$ | PSNR$\uparrow$ | SSIM $\uparrow$ | PSNR $\uparrow$ | SSIM $\uparrow$ | $\Delta$PSNR/SSIM |  |
| Denoising | 23.11dB | 0.49 | 19.96dB | 0.65 | 26.77dB | 0.80 | +6.81dB/+0.15 |
| Deblurring | 30.88dB | 0.83 | 26.14dB | 0.78 | 26.23dB | 0.79 | +0.09dB/+0.01 |
| Deraining | 20.52dB | 0.84 | 19.96dB | 0.74 | 24.62dB | 0.77 | +4.66dB/+0.03 |
| Pepper Removal | 19.22dB | 0.51 | 23.01dB | 0.58 | 25.20dB | 0.75 | +2.19dB/+0.17 |
| Mask Removal | 20.54dB | 0.83 | 20.00dB | 0.73 | 25.83dB | 0.80 | +5.83dB/+0.07 |
| Rotation | inf(^6^66Some implementation will return a PSNR score of 100 when two images are identical. We stick to the mathematical definition of PSNR here and return infinite PSNR score when two images are the same.) | 1.00 | 29.52dB | 0.89 | 27.18dB | 0.83 | -2.34dB/-0.06 |
| Flipping | inf | 1.00 | 29.52dB | 0.89 | 27.28dB | 0.84 | -2.24dB/-0.05 |

Figure: Figure 3: A frozen LLM shows non-trivial capability on various low-level vision tasks.
Refer to caption: x3.png

### 4.3 Choice of Vision Module Matters

The key component in our method is the visual module. While we have successfully showed LLM’s low-level visual feature processing ability using a fine-tuned MAE, it prompts an investigation into how different visual modules might affect the outcomes.

There are actually not many choices of vision modules for unsupervised image reconstruction. A common choice is VQ-GAN, a state-of-the-art representative of the VAE family.
Another less common choice is BEiT [], which is originally used for image recognition. The training goal of BEiT involves predicting the masked tokens of the DALL-E tokenizer(^7^77OPENAI public release at https://cdn.openai.com/dall-e/decoder.pkl & https://cdn.openai.com/dall-e/encoder.pkl) [], which can be decoded into images by the DALL-E’s decoder.
In practice, we find that BEiT’s predictions are accurate enough to roughly reconstruct images even without fine-tuning, potentially due to a lower masking rate during training compared to MAE.

We use MAE, VQGAN and BEiT as the vision module in our pipeline and evaluate their performance. We start with a trivial task: image repetition. The LLM is asked to repeat the input image. As shown in Fig. 4, all three modules succeed in performing identity mapping. However, asked for a slightly more complex task: image rotation, VQGAN and BEiT produces messy images with no semantic meaning, while MAE still performs well. This indicates that the choice of vision module is important for the success of our method. More discussion can be found in Appendix A.3.

Figure: Figure 4: All three modules succeed in performing image repetition, but VQGAN and BEiT totally fail for image rotation.

### 4.4 Auto-regressive Generation Matters

Another question to consider is the necessity of auto-regressive (AR) generation. Indeed, AR is not the mainstream approach for image generation. Current AR methods [, , , ] often underperform diffusion-based methods [, ] and tend to require higher computational costs. Therefore, we design a more straightforward, more vision-style generation scheme. We feed the degraded image tokens to the LLM and expect it to directly output curated image tokens in a single forward process. We call this generation process "ViT-LLM generation", as it treats LLM as a normal ViT. We still use the $l_{2}$-regression on visual features as the training objective.

In the training process, the trainable parameters in this process are two linear adaptation layers. Furthermore, we cancel the causal attention mask and the ROPE position embedding [] in the forward process, as they are not the common practice for vision modules. We test this generation scheme on image denoising, under the experiment setup mentioned in Sec. 4.1. As shown in Fig. 5, ViT-LLM generation produces low-quality and blurred images, even when the noise level is low. This indicates auto-regressive generation is essential for our success. Moreover, using auto-regressive feature generation naturally aligns with LLM’s behavior, and can be seamlessly plugged into LLM’s generation as an additional encoding and decoding module.

Figure: Figure 5: ViT-LLM generation fails for image denoising even when the noise level is low (2nd row), producing low-quality and blurred images.

## 5 Abalation Studies

In order to ensure that it is the LLM rather than other modules that plays the crucial role in processing low-level features, we have intentionally simplified the design of other components. However, we still require extensive ablation study to further validate the importance of the LLM. We also investigate a single LLM layer’s capacity in Appendix B.3 and explore more base LLMs in Appendix B.2.

### 5.1 Is the Linear Layer Doing the Task?

Although our adaptation modules are intentionally simplified to a simple linear layer, we still need to verify whether it is the adaptation module that accomplishes the low-level vision tasks. To this end, we remove the LLM component and the auto-regressive generation process from the model, leaving only the linear adaptation module. At this stage, the training objective is use a linear layer to map the low-quality visual features to high-quality visual features produced by MAE.

We train the linear layer using $l_{2}$ regression for image denoising, under the same setup as described in Sec. 4.1. Some visualizations are shown in Fig. 6. It is evident that a single linear layer is insufficient to handle low-level vision tasks effectively. Though the main structure of the images remains, the images have weird colors and are divided into patches.

Additionally, we observe that through training, two linear layers tend to perform a scaled identity mapping even though they are not forced to do so. This further evidences the importance of LLM in processing visual features. More analysis can be found in Appendix B.1.

Figure: Figure 6: Using a single linear layer for denoising yields bad results.

### 5.2 Does Text Pre-training Play an Important Role?

Some studies [, ] have found that a randomly initialized CNN module can already serve as an effective representation extractor, suggesting that the architecture of the model itself possesses the ability to solve various tasks. Thus, a natural question arises: Does text pre-training endow the LLM with the ability to solve low-level vision tasks, or is the capability inherent to the LLM’s architecture itself? [] requires numerous random initializations are required to define kernels for classification purposes, yet the integration of multiple random initializations with auto-regressive generation on an LLM has not been discussed. Therefore, we only initialized the LLM randomly once and maintained the architecture unchanged, testing its denoising performance under the setup in 4.1.
Visualizations from Fig. 7 demonstrate that the randomly initialized LLM fails to generate meaningful images, indicating that text pre-training is crucial for the LLM to solve low-level vision tasks.

Figure: Figure 7: Using randomly initialized LLM gives messy outputs.
Refer to caption: x7.png

### 5.3 LLM vs Expert Models

Although we have validated the capability of LLMs to process visual features, the question remains, by how much? To quantitatively assess the capability of LLMs, we replaced the LLM with either an 2-layer MLP or a one-layer Transformer, serving as expert models to solve visual tasks. To ensure fair comparisons, the MLP and Transformer have nearly the same number of trainable parameters as our method. For the expert models, we adopted the same design described in Sec. 5.1, replacing the linear layer with the expert model.

We test the performance of expert models on image denoising and image rotation, under the exact same setup as mentioned in Sec. 4.1. From Table 3, our method surpasses the MLP baseline but falls behind the Transformer baseline in image denoising tasks. But both MLP and Transformer fail to do image rotation, whereas LLM can handle it well. This proves LLMs’ non-trivial low-level feature processing capability.

Table: Table 3: Comparisons of different expert models and our methods. Using LLM gain superior performance in image rotation, and surpass MLP in image denoising. Best results are in bold.

|  | Denoising | Rotation |  |  |
| --- | --- | --- | --- | --- |
|  | PSNR$\uparrow$ | SSIM $\uparrow$ | PSNR$\uparrow$ | SSIM $\uparrow$ |
| MLP | 25.87dB | 0.76 | 13.29dB | 0.32 |
| Transformer | 27.42dB | 0.81 | 10.52dB | 0.23 |
| Ours* | 26.77dB | 0.80 | 27.18dB | 0.83 |

### 5.4 Discussion & Limitations

Discussion. Our work could lead to some interesting topic beyond enabling LLMs for low-level vision tasks. As stated, the goal for this work is not to achieve the best performance in image restoration, but to demonstrate the potential of LLMs in processing low-level features and show a possible way to leverage LLMs’ strong reasoning and interaction ability to low-level vision tasks. Also, as LM4LV does not involve any multi-modal data, this framework could be extended beyond vision to the fields where cross-modal data is scarce by replacing MAE with a self-supervised field-specific module.

Limitations.
As shown in Fig. 3, LM4LV could not restore high-frequency details in degraded images. This is natural because the LLM does not have image prior, which could be improved by adding skip-connection or multi-modal data. But this is not the focus of this work. Also, the performance gap observed between our method and a one-layer Transformer also indicates that there is room for improvement in our approach.

## 6 Conclusion

In this work, we aim to answer the question: Does a frozen LLM has the ability to accept, process, and output low-level features? By designing a framework from bottom to top, we give a positive answer, showing LLMs’ non-trivial performance on various low-level tasks. We hope this work can inspire new perspectives on the capabilities of LLMs and deeper understanding of their mechanisms.

## Appendix A More Implementation and Experiment Details

### A.1 MLLMs’ Inability to See Low-level Visual Features

In this section we give more detail about how MLLMs fail to process low-level visual features.
As shown in Tab. 4, we group MLLMs with conditional image generation ability into three categories based on the type of vision embedding they use: token, unknown, and feature. We show that our
method LM4LV is capable of image reconstruction, while have no need any heavy pre-training and any multi-modal data.

For closed-source models with no access to the vision module, we test a similar task: image repetition. That is, we prompt the model to repeat the input image without any modification. We show that Gemini [], GPT-4V and GPT-4o fail to repeat the input image, giving highly semantic related images that are different in low-level details. We give the visualizations of image repetition tasks in Fig. 8. But we would like to note this is a naive approach to test the capability of vision modules, and the results could be improved with more detailed and sophisticated prompts.

**Table 4: Most MLLMs with conditional image generation ability fails for image reconstruction. Listed are MLLMs that unify comprehension and generation, grouped by vision embedding type. “Features” means continuous features, “Token” represents discrete tokens. Multi-modal backbone pre-training represents that the model needs a large corpus of multi-modal data for pre-training. Multi-modal vision encoding/decoding indicates that the vision encoder/decoder is trained under multi-modal data or supervised by additional multi-modal modules. N/A means we have no knowledge of the vision module.**
| Vision<br>Embedding<br>Type | Model | Conditional<br>Image<br>Generation | Multi-modal<br>Backbone<br>Pre-training | Multi-modal<br>Vision Encoding | Multi-modal<br>Vision Decoding | Open-<br>source | Image<br>Reconstruction |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Token | SEED-OPT | $\checkmark$ | LoRA | $\checkmark$ | $\checkmark$ | $\times$ | $\times$ |
| LaVIT | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ |  |
| SEED-LLaMA | $\checkmark$ | LoRA | $\times$ | $\checkmark$ | $\checkmark$ | $\times$ |  |
| Unknown | Gemini | $\checkmark$ | $\checkmark$ | N/A | N/A | $\times$ | $\times$ |
| GPT-4V | $\checkmark$ | $\checkmark$ | N/A | N/A | $\times$ | $\times$ |  |
| GPT-4o | $\checkmark$ | $\checkmark$ | N/A | N/A | $\times$ | $\times$ |  |
| Feature | Emu | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ |
| VL-GPT | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ | $\times$ |  |
| DreamLLM | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ | $\times$ |  |
| Emu2 | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ |  |
| NExT-GPT | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ |  |
| SEED-X(^8^88SEED-X is capable of image reconstruction if the vision decoder is provided with the original images. But here we adopt the w/o original image setting.) | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\checkmark$ | $\times$ |  |
| LM4LV(ours) | $\checkmark$ | $\times$ | $\times$ | $\times$ | $\checkmark$ | $\checkmark$ |  |

Figure: Figure 8: Image repetition results of Gemini, GPT-4V and GPT-4o. The models fail to repeat the input image, giving highly semantic related images that are different in low-level details. We note that the results could be improved with more detailed and sophisticated prompts.
Refer to caption: x8.png

### A.2 Fine-tuning Details of MAE

As shown in Fig. 10, directly using MAE for image reconstruction results in poor performance. No previous work has demonstrated the capability of MAE for image reconstruction, and through our experiments, we found that MAE is capable of reconstructing images if fine-tuned properly.
To ensure the representation of the visual features is not changed during fine-tuning, we freeze the encoder and only train the decoder. Given an image $x$ and it’s MAE reconstruction $\tilde{x}$, we use a reconstruction L1 loss and a LPIPS loss as the training objective, defined as follows:

$$ $\mathcal{L}=\left|x-\tilde{x}\right|+\lambda\cdot\text{LPIPS}(x,\tilde{x})$ (1) $$

Following the training recipe in VQGAN [], we set $\lambda=1$. Following the pre-training recipe of MAE, we use an actual batchsize of $4096$ and a basic learning rate of $1e-4$. The actual learning rate is scaled by batchsize / 256. We use the AdamW optimizer with $\beta=(0.9,0.95)$ and a weight decay of 0 0. We use warm-up decay scheduling with a warm-up step of $100$. We train the model on ImageNet for 28 epochs without data augmentation. All images are resized to $224\times 224$, matching the input size of MAE. Though we use MAE to model degradations in our experiment, we do not include degraded images into the training data. This further evidences MAE’s strong generality.

Additionally, we would like to note that LPIPS requires a VGG model as supervision, which is trained on image-label data pairs. However, we re-state that the encoder is frozen during the fine-tuning process. Thus the encoder is still trained in an unsupervised manner, and the LLM only have access to the unsupervised visual features. Thus, though the decoder is trained under slightly supervised manner, it does not affect our conclusion that the LLM is capable of processing and outputting unsupervised visual features.
Moreover, only using L1 loss as the training objective still achieves a good performance as shown in Tab. 1. We visualize the reconstruction results of MAE fine-tuned under different objectives in Fig. 10.

Another interesting topic is how fine-tuning effects the original MAE’s capability i.e. reconstructing masked tokens. As shown in Fig. 9, the fine-tuned MAE totally loss the capability of reconstructing masked tokens, producing messy patches for them. However, MAE is still able to reconstruct the unmasked tokens, indicating that the fine-tuned MAE decoder has a strong locality.

Figure: Figure 9: The fine-tuned MAE decoder tends to have a strong locality. We mask the diagonal image tokens and use MAE for reconstruction. The fine-tuned MAE is able to reconstruct the unmasked tokens well, but fails to reconstruct the masked tokens.
Refer to caption: x9.png

Figure: Figure 10: Directly using MAE for reconstruction gives bad-quality images. Using L1-loss to fine-tune MAE gives a much better performance. The LPIPS loss further improves the quality of the reconstructed images.
Refer to caption: x10.png

### A.3 Choice of vision modules

VQGAN We use a publicly available VQGAN from [], with a downsample rate of 16 and a vocabulary size of 16384. The state-of-the-art VQVAE has $32\times 32=1024$ tokens, which is way larger than MAE (197) and BEiT (197), thus we use a version with inferior performance but much fewer tokens ($16\times 16=256$) for a faster training and fairer comparison.

A VQ-GAN will first encodes images into 2D feature matrixs. We flatten the feature into 1D in raster scan order to obtain visual tokens.

BEiT We use BEiT-Large(^9^99[https://github.com/addf400/files/releases/download/v1.0/beit_large_patch16_224_pt22k.pth](https://github.com/addf400/files/releases/download/v1.0/beit_large_patch16_224_pt22k.pth)), trained under ImageNet22k in an unsupervised manner. BEiT encodes an image to 197 tokens, including a CLS token. Though the DALL-E decoder does not need CLS token for decoding, we still add CLS token into visual tokens as CLS may guide the LLM for later generation. However, two factors limit BEiT to be a good model for image reconstruction. First, BEiT uses DALL-E as the tokenizer, which is relatively bad at image reconstruction. DALL-E owns a reconstruction FID of 32.01 on Imagenet validation set, which is ten times higher than the VQGAN we use. Secondly, BEiT uses a input image size of $112\times 112$ for DALL-E, which is different from the training image size of DALL-E ($256\times 256$). This further hurts the performance of BEiT in image reconstruction.

As shown in Sec. 4.3, using VQGAN and BEiT as the vision module in our pipeline fails even for image rotation. Why is it? A very recent work [] purpose a hypothesis that models of different modalities are learning similar representations, and the similarity can be quantified using pre-defined kernel distance. They show a stronger vision learner learns more similar representation to that of LLMs. From the perspective of linear probing, MAE is definitely a much stronger vision learner than VQGAN and BEiT. Thus, MAE may be more aligned with LLMs. Thus LLM is more easy to process the visual features of MAE than that of VQGAN and BEiT. We further side-prove this alignment using vision-language tasks.

We freeze the vision encoder and the LLM, and train a linear layer to project the visual features into the LLM’s feature space under image captioning tasks. The training setup is identical to the first stage of LLAVA [], except we choose a 100k subset of LLAVA595k for quicker training. We then test the ClipScore and Ref-ClipScore [] on the NoCaps dataset. As shown in Tab. 5, MAE has a far higher ClipScore and Ref-ClipScore than BEiT, while BEiT is slightly better than VQGAN. This could be a possible explanation for the failure of VQGAN and BEiT in our pipeline.

Table: Table 5: ClipScore and Ref-ClipScore of different vision encoders. Random represents to use 10 random letters as the generated caption.

|  | CS$\uparrow$ | Ref-CS $\uparrow$ |
| --- | --- | --- |
| Random | 34.38 | 46.01 |
| BEiT | 37.52 | 47.78 |
| MAE | 46.97 | 55.56 |

## Appendix B Analysis and Discussion

### B.1 Linear Adapters Tend to Perform a Identity Mapping

We found that though not explicitly trained to do so, the linear layers in LLM tend to perform a scaled identity mapping $\alpha I,\alpha\in R$.
Fig 11 shows the visualized result of the multiplication of two weight matrix in the linear layers. It can be seen that the weight of the results centers mostly on the diagonal of the matrix. We further numerically analyze how close the matrix is to a scaled identity matrix. Specifically, we define two metric as a way to measure the similarity between a matrix $A$ and an scaled identity matrix $\alpha I,\alpha\in R$:

$$ $\left\{\begin{aligned} \mathcal{L}(A)&=\min_{\alpha}\|A-\alpha I\|^{2}_{2}\\ \mathcal{D}(A)&=\frac{1}{n(n-1)}\sum_{i\neq j,i,j\in[1,n]}\left|\frac{A_{i,i}} {A_{i,j}}\right|\end{aligned}\right.$ $$

From Tab. 6, the linear layers obtained by training have a $\mathcal{L}$ and $\mathcal{D}$ very similar to a identity matrix. This indicates the linear layers tends to be a scaled identity mapping even though they are not forced to do so, which further evidences the importance of LLM in processing visual features.

**Table 6: Our multiplication matrix have $\mathcal{L},\mathcal{D}$ similar to that of an Identity matrix. Random represents a randomly initialized weight subject to standard Gaussian distribution. Identity represents an identity mapping.**
|  | Random | Ours | Identity |
| --- | --- | --- | --- |
| $\mathcal{L}$ | $1.00$ | $5.26\times 10^{-4}$ | 0 0 |
| $\mathcal{D}$ | $12.52$ | $1.53\times 10^{4}$ | inf |

Below we first clarify our definition of $\mathcal{L}$ and $\mathcal{D}$, and then provide an analysis of the expectation of $\mathcal{L},\mathcal{D}$ on a randomly initialized matrix $N^{n\times n}$.

Clarification. Ideally, we expect the linear layer to do nothing except for a simply identity mapping with a constant scaling(with a constant shift brought by the bias). That is, we want the multiplication matrix $A$ to be close to $\alpha I$, where $\alpha$ is a constant and $I$ is the identity mapping. If so, the linear layer will not change the input features(except for a scaling), and we can prove that it is LLM that is processing the visual features.
Therefore, $\mathcal{L}(A)$ is defined as a minimum l2-distance between $A$ and a scaled identity mapping w.r.t $\alpha$. A smaller $\mathcal{L}(A)$ indicates $A$ is closer to a scaled identity mapping.
Additionally, a scaled identity mapping should have it’s weight centered on the diagonal, thus we additionally defined $\mathcal{D}(A)$ as the average ratio of the diagonal elements to the off-diagonal elements. A larger $\mathcal{D}(A)$ indicates the weight matrix is more diagonal dominant.

Analysis. We first proof for a matrix $N^{n\times n}$ with weights randomly initialized subject to $\mathcal{N}(\textbf{0},I_{n})$, we have $\mathbb{E}[\mathcal{L}(N)]=1-\frac{1}{n^{2}}$. In our case $n=1024$, so $\mathbb{E}[\mathcal{L}(N)]=1-\frac{1}{2^{20}}\approx 1$.

We first simply $\mathbb{E}[\mathcal{L}(N)]$:

$$ $\displaystyle n^{2}\mathbb{E}[\mathcal{L}(N)]$ $\displaystyle=\mathbb{E}[\min_{\alpha}\sum_{i,j}(N_{i,j}-\alpha I_{i,j})^{2}]$ $\displaystyle=\mathbb{E}[\sum_{i\neq j}N^{2}_{i,j}+\min_{\alpha}\sum_{i}(N_{i, i}-\alpha)^{2}]$ $\displaystyle=n(n-1)\mathbb{E}[N^{2}_{0,0}]+\mathbb{E}[\min_{\alpha}\sum_{i}(N _{i,i}-\alpha)^{2}]\quad\texttt{weights are i.i.d}$ $\displaystyle=n(n-1)(\mathrm{Var}(N_{0,0})+\mathbb{E}^{2}[N_{0,0}])+\mathbb{E} [\min_{\alpha}\sum_{i}(N_{i,i}-\alpha)^{2}]$ $\displaystyle=n(n-1)+\mathbb{E}[\sum_{i}(N_{i,i}-\frac{1}{n}\sum_{j}N_{j,j})^{ 2}]\quad\texttt{using linear regression}$ $$

For the second term, we have:

$$ $\displaystyle\mathbb{E}[\sum_{i}(N_{i,i}-\frac{1}{n}\sum_{j}N_{j,j})^{2}]$ $\displaystyle=\sum_{i}\mathbb{E}[(N_{i,i}-\frac{1}{n}\sum_{j}N_{j,j})^{2}]$ $\displaystyle=\sum_{i}(\mathbb{E}[N^{2}_{i,i}]-\frac{2}{n}\sum_{j}\mathbb{E}[N _{i,i}N_{j,j}]+\frac{1}{n^{2}}\sum_{j}\mathbb{E}[N^{2}_{j,j}])$ $\displaystyle=\sum_{i}(1-\frac{2}{n}+\frac{1}{n^{2}}\times n)\quad\texttt{$N_{ i,i}\perp N_{j,j}(i\neq j),\mathbb{E}[N_{i,i}]=0$}$ $\displaystyle=n-1$ $$

Thus we have:

$$ $\mathbb{E}[\mathcal{L}(N)]=\frac{1}{n^{2}}[n(n-1)+(n-1)]=1-\frac{1}{n^{2}} \approx 1(n\to\infty)$ $$

For $\mathcal{D}(N)=\frac{1}{n(n-1)}\sum_{i\neq j}N_{i,i}/N_{i,j}$, it’s well known that the ratio of two i.i.d Gaussian random variables subjects to a Cauchy distribution, which has no expectation. Thus we can not provide a theoretical expectation for $\mathcal{D}(N)$. However, the reason for the non-existence of expectation is a non-zero probability density at zero for a Gaussian distribution. However, computers compute and store numbers with a finite precision, thus the actual distribution is discrete. Thus, if we manually set the probability of zero to zero, the expectation of such discrete distribution will be extractable. As the discrete distribution is hard to compute and differs when using different precision (e.g. float32, bfloat16), we compute an empirical expectation of $\mathcal{D}(N)$ by randomly sample $1\times 10^{6}$ i.i.d variables subject to Cauchy distribution and calculate the average. The final expectation converges to 12.52.

### B.2 More Base Models

To show the generalizability of our method across different LLMs, we test our method on more base models. We use base models from the llama family, namely LLAMA2-13B, LLAMA3-8B and LLAMA3-8B-instruct. We use the same training setup as in Sec. 4.1 for image denoising task. The results can be seen in Fig. 12. We observe that our method is able to process visual features across different LLMs, with a consistent performance improvement over the baseline. Interestingly, the performance of our method is not always positively correlated with the size of the LLM, and the instruct version of Llama3 has a lower performance than the non-instruct version. We leave the exploration of this phenomenon for future work.

Figure: Figure 12: PSNR of denoising using different base models. MAE-r represents the MAE reconstruction baseline.
Refer to caption: x12.png

### B.3 Can a Single LLM Layer Process Low-level Features?

A recent work [] reveals an interesting phenomenon: the Transformer layers in a LLM are capable of facilitating various supervised visual tasks, such as image classification and 3D point cloud classification. Specifically, [] implemented an approach where a frozen Transformer layer was added to a Vision Transformer (ViT) backbone, and two linear layers were used for the transition between visual features and the Transformer layer. We employed a similar strategy, except that in [], the ViT backbone and the linear layers were trained together from scratch, whereas we only trained two linear layers. We extract the frozen Transformer layer from LLAMA2-7B-instruct. Following [] we cancel the causal attention mask and positional embedding. Similar to , we set an baseline of using a MLP with approximately same trainable parameters as a baseline.

The numerical results can be seen in Fig 6. It is clear a frozen Transformer layer extracted from LLM can help solving low-level vision tasks, with a performance consistently higher than the MLP baseline. Moreover, we observe that the performance variations across different layers of the llama model align with the trends reported in []. Specifically, layer 8 exhibited the best performance, with a gradual decline observed in deeper layers. This finding allows us to extend the conclusions from  []—that LLM layers can aid in supervised vision/language tasks—to unsupervised visual tasks. This suggests that the mechanisms by which LLM layers contribute to performance may be broadly applicable across different types of visual processing tasks.

Figure: Figure 13: PSNR of denoising using different layers in LLM. MLP represents the MLP baseline.
Refer to caption: x13.png

## Appendix C Visualizations

### C.1 Failure Case

As we’re using an auto-regressive scheme for visual feature generation, inevitably there will be cases that auto-regressive generation falls into wrong generation. We observe that occasionally the model will mess up the order of visual tokens, producing misaligned images. As shown in Fig. 14, the model fails to align the visual tokens correctly in image denoising task, resulting in a distorted image. We note that in this case the PSNR and SSIM of the generated image and the original image would be very low as PSNR and SSIM apply a per-patch comparison. However, the model still denoises the images correctly.

Figure: Figure 14: Failure case of our method. Occasionally, The model fails to align the visual tokens correctly, resulting in a distorted image. However, the model still denoises the images correctly. Zoom in for details.
Refer to caption: x14.png

### C.2 Visualizations of LM4LV

We give more visualizations of LM4LV in Fig. 15.

Figure: Figure 15: Visualizations of LM4LV on various tasks. Top row: degraded images. Middle row: MAE-r. Bottom row: LM4LV.
Refer to caption: x15.png

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: None
soundness: 3
strengths: (1) It proves frozen LLM can solve low-level vision task
(2) The ablation experiment is sufficient to answer that the processing of low-level information is not due to the trainable linear layer, but the text pre-training plays a role
summary: This paper analyzes the reasons why most MLLMs cannot handle low-level features and then puts forward a simple solution. It uses MAE fine-tuning with Image reconstruction tasks to save low-level features. After that, it is then interesting to find that frozen LLM can understand low-level features, which taps into the LLM's uncanny ability to understand visual features.
weaknesses: vision encoder selection is relatively small, exploring more vision encoders will be more convincing

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. Why fine-tune MAE to perform image reconstruction, instead of using MAGE or MaskGIT? MAGE and MaskGIT use the MIM training paradigm to perform image reconstruction. Will they achieve better performance than MAE?
2. In sec. 5.2, the authors claim they randomly initialize the LLM. After the random initialization, is the LLM frozen or fine-tuned? It would be interesting if the LLM is fine-tuned but still underperforms the frozen LLM counterpart.
soundness: 2
strengths: + The proposed method is simple and easy to understand.
+ This work is the first to use LLM for low-level vision tasks.
+ Some conclusions in the paper are interesting. E.g. MAE visual tokens are robust to rotation.
summary: This paper proposes a novel framework, named LM4LV, which applies MLLM to low-level vision tasks. Through preliminary experiments, the authors highlight the advantages of MAE in preserving detailed visual features. Therefore, MAE is used as the visual encoder in LM4LV. Keeping the LLM and visual encoder frozen, the training of LM4LV can be conducted without multimodal data. Extensive experiments are conducted on various low-level vision tasks and different vision modules, to verify the low-level vision task capability of LLM.
weaknesses: - It would be helpful if the authors could specify the number of visual tokens generated by MAE for each image. Moreover, the discussion about computation cost is missing.
- While in sec. 4.1, the authors use MAE-r model as a baseline. Since MAE-r is trained for image reconstruction only, the baseline is not very strong. To establish a stronger baseline, the authors can consider adding the linear adapters into MAE-r, and train the linear adapters for image restoration tasks. Ideally, the linear adapters should be trained separately for each image restoration task, with the same recipe used for training LM4LV.
- Lack of comparison with traditional low-level vision methods. I'm not an expert in low-level vision tasks, so a dedicated part in the related works section would be helpful. Moreover, I don't see any comparison between the proposed LM4LV framework and the previous low-level vision methods. 
- The presentation contains several typos. In line 018 "we purpose LM4LV" and line 039 "purpose to use LLMs", should the word "purpose" be "propose"? In line 471 "(Amid et al., 2022) requires", the citation format can be corrected. In line 914, "ativation" might be a typo.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: NA
soundness: 3
strengths: Pro:
1. The paper tackles an interesting research direction by investigating whether frozen LLMs can handle low-level vision tasks without multi-modal training, addressing a significant gap in current MLLM research.
2. The authors propose LM4LV, an efficient framework that achieves impressive results across multiple low-level vision tasks using only two trainable linear layers while keeping the LLM frozen.
3. The paper provides thorough empirical analysis through comprehensive ablation studies, particularly demonstrating the necessity of auto-regressive generation, the importance of choosing appropriate vision modules, and the effectiveness of each module, which helps validate the framework's design choices.
summary: The authors introduce LM4LV, a framework that enables frozen LLMs to handle low-level vision tasks (like image denoising and deraining) without requiring multi-modal data or prior training. Through comprehensive experiments, the authors demonstrate the framework's effectiveness by showing significant improvements over baselines and reveal two crucial design choices: the necessity of auto-regressive generation and the importance of vision module selection.
weaknesses: Cons:
1. The paper said, “Furthermore, we cancel the causal attention mask and the ROPE position embedding in the forward process, as they are not the common practice for vision modules.”. However, the ROPE and it variant 2D-ROPE are widely used in large vision transformers (e.g., EVA). This sentence needs revision, and additional experiments with position embeddings would strengthen the analysis.
2. The paper does not explore different LLM variants and sizes. While testing very large LLMs may be resource-intensive, experimenting with smaller or comparable models (like LLaMA-3.2-3B or Qwen2.5 series) would provide valuable insights into how model architecture and scale affect performance.

Suggestion:
1. The paper would benefit from including comparisons with state-of-the-art (SOTA) results from mainstream methods for each low-level vision task. The readers do not expect the method to outperform SOTA methods, while a clear comparison might be helpful for the readers to understand the position of the paper.
2. It would be valuable to investigate the effectiveness of non-autoregressive language models like BERT for low-level vision tasks. While the paper's experiments show that removing auto-regressive generation from LLMs significantly degrades performance, it alters the pre-trained model. Testing with models that are inherently non-autoregressive (like BERT) could provide clearer insights into whether the auto-regressive nature of LLMs is truly essential for these tasks or if alternative architectures might be viable with proper adaptations.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: This paper study the use of LLM for low-level vision tasks, which is under-explored. However,  the motivation to use LLM for these tasks are a bit weak, and the model struggles to preserve high-frequency details in degraded images, suggesting room for further exploration in loss functions or architectural enhancements.
soundness: 2
strengths: 1. The paper addresses an under-explored area in multimodal research by extending LLMs to low-level vision tasks without requiring multimodal training.

2. Comprehensive experiments cover diverse low-level tasks, including denoising, deblurring, and pepper noise removal.
summary: The paper presents LM4LV, a framework that enables a frozen large language model (LLM) to handle low-level vision tasks, such as denoising and deraining, without any multimodal data or prior. By combining a masked autoencoder (MAE) with a frozen LLM and two linear adapters, LM4LV demonstrates non-trivial capabilities in various low-level image processing tasks, thus bridging a gap between large vision-language models (LVLMs) and low-level vision.
weaknesses: 1. The paper could benefit from a broader comparison with other non-LLM approaches, particularly in vision-language domains, to better position LM4LV’s relative advantages.

2. The motivation to use LLM for these low-level vision tasks, instead of task-specific models, are still not clear.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. In the line 54-57, paper claims that "Enabling MLLMs to process low-level features can lead to a more fine-grained understanding of images and better control in the process of image generation." It's there any fine-grained qualitative or qualitative results to prove that? 

2. I can't understand the Fig.3, is there lack of labels?

3. For the auto-regressive process, the image tokens a limited in the <img> and </img>, so how to control the number of image tokens to make it same with the original image?

4. What is the order of auto-regressive, as row or column? Is there any difference when use different order to generate the image tokens?
soundness: 2
strengths: 1. LM4LV explores the potential of LLM in handling with the vision data without any multi-modal data, which can provide some references.

2. Detailed appendices provide the analysis and the process of implementation. It's easy to follow it. 

3. The paper is well written and easy to understand.
summary: The paper proposes a framework called LM4LV to explore the ability of vanilla Large Language Model in handling with the low-level vision task. LM4LV utilizes the fine-tuned MAE to extract the image features, and take two linear layers as the bridge from vision to language. A paired decoder is used to transform the output tokens to images. It shows competitive quality results in denoising, deblurring, deraining and so on, but the effective in spatial operations like rotation and flipping is ordinary.
weaknesses: 1. Contribution. The contribution is limited. LM4LV relies on the existing auto-regressive ability from the training process in LLM. It only constructs a linear layer as the bridge to align the vision semantic space and language semantic space to predict the next token.

2. Soundness. The soundness of the paper is fair. It only utilizes the LLM as a next token predictor, and not explores another way to process vision information by LLM directly. 

3. The qualitative results are not fair. The comparisons with other methods should cover the other denoising, deblurring, deraining methods like MAXIM [1], Restormer [2]

4. The novelty is limited. The framework is composed with a fine-tune MAE and a LLM.

[1] Maxim: Multi-axis mlp for image processing, CVPR 22
[2] Restormer: Efficient transformer for high-resolution image restoration, CVPR 22

Meta-review: The paper introduced LM4LV, a new framework for low-level vision, which uses a frozen LLM to solve low-level vision tasks. The authors use MAE as the visual encoder, combine it with LLM and keep both frozen, the training of LM4LV can be conducted without multimodal data. The experiments demonstrate the low-level vision capability of LM4LV.

This paper is interesting to me. It explored a new direction and problem, which shows that frozen LLMs with proper approach can solve low-level vision tasks to som extent.

But the concerns about insufficient ablations, low performance and efficiency, and unclear motivation/advantage do exist.

I recommend rejecting as the current state, but the decision can be bumped up.
I would suggest that the authors explore the potential advantages further. Again, I think this is a interesting exploration.

Decision: Reject