Delta-CoMe: Training-Free Delta-Compression with Mixed-Precision for Large Language Models

Authors: bowen  ping
shuo  wang
hanqing  wang
xu  han
yuzhuang  xu
yukun  yan
yun  chen
baobao  chang
zhiyuan  liu
maosong  sun
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-15 17:56:03

Abstract: Fine-tuning is a crucial process for adapting large language models (LLMs) to diverse applications. In certain scenarios, such as multi-tenant serving, deploying multiple LLMs becomes necessary to meet complex demands. Recent studies suggest decomposing a fine-tuned LLM into a base model and corresponding delta weights, which are then compressed using low-rank or low-bit approaches to reduce costs. In this work, we observe that existing low-rank and low-bit compression methods can significantly harm the model performance for task-specific fine-tuned LLMs (e.g., WizardMath for math problems). Motivated by the long-tail distribution of singular values in the delta weights, we propose a delta quantization approach using mixed-precision. This method employs higher-bit representation for singular vectors corresponding to larger singular values. We evaluate our approach on various fine-tuned LLMs, including math LLMs, code LLMs, chat LLMs, and even VLMs. Experimental results demonstrate that our approach performs comparably to full fine-tuned LLMs, surpassing both low-rank and low-bit baselines by a considerable margin. Additionally, we show that our method is compatible with various backbone LLMs, such as Llama-2, Llama-3, and Mistral, highlighting its generalizability.

Main paper: 
 introduction: 
 Large language models (LLMs) (Touvron et al., 2023; Jiang et al., 2023) are increasingly becoming the standard for a wide range of downstream tasks (Luo et al., 2023a; Yu et al., 2023; Wei et al., 2023; Luo et al., 2023b; Liu et al., 2024a; Wang et al., 2023) , significantly surpassing conventional small models. To meet the demands of various application domains and scenarios, many researchers direct their attention to developing advanced alignment or adaptation algorithms together with diverse training data to learn aligned LLMs based on generally pre-trained models. For instance, Luo et al. (2023a) propose a reinforcement learning from evol-instruct feedback (RLEIF) method to construct LLMs with strong mathematical reasoning abilities. Similarly, Yu et al. (2023) employ a bootstrapping method to diversify mathematical questions and then fine-tune open-source LLMs to build mathematical models. For code generation, Luo et al. (2023b) adapt the evol-instruct method to the coding domain, resulting in the WIZARDCODER model, which demonstrates superior coding abilities compared to generally trained LLMs. Additionally, Wei et al. (2023) enhance the capabilities of open-source code LLMs by using automatically generated high-quality instruction data based on Figure 1 : Left: illustration of BitDelta (Liu et al., 2024b) , which employs 1-bit quantization for all the delta weights. Middle: illustration of low-rank compression (Ryu et al., 2023b) , retaining the top-k singular values and the corresponding singular vectors. Right: illustration of the proposed Delta-CoMe method, which represents the singular vectors of larger singular values using high-bit vectors while compressing the singular vectors of smaller singular values into low-bit representations. This method is inspired by the long-tail distribution of singular values in delta weights.existing code snippets. Wang et al. (2023) utilize various resources of mixed quality and design a new conditioned reinforcement learning fine-tuning method to train the OPENCHAT model. Beyond the text modality, some studies propose fine-tuning pre-trained LLMs to understand other modalities.For instance, Liu et al. (2024a) construct a multi-modal instruction tuning dataset and develop the LLAVA model, which can understand both text and images.Building on the aforementioned alignment approaches, LLMs are endowed with specialized capabilities that align with distinct user demands and application requirements (Liu et al., 2024b) . In certain scenarios, deploying multiple LLMs with different abilities is necessary. For example, in multi-tenant serving, different LLMs may be needed to satisfy various users. Additionally, some complex tasks consist of multiple sub-tasks, each requiring different model capabilities. To address these tasks, we should organize and deploy a group of LLMs simultaneously. A straightforward question arises: why not use a single general LLM that encompasses all the necessary capabilities? For example, we could develop one model that can both understand images and generate code programs. To our knowledge, LLMs with various capabilities (e.g., GPT-44 ) typically have an enormous number of parameters, making them impractical for resource-limited situations (e.g., edge-side scenarios).In pursuit of this objective, a field of research advocates for the minimization of expenses associated with multi-model serving. Delta-compression emerges as a crucial and viable approach in this context, offering the potential to decrease both storage requirements and GPU memory utilization in scenarios involving multiple models. The primary objective of delta-compression is to minimize the size of the delta weights between aligned and pre-trained LLMs (e.g., LLAMA-2-CHAT and LLAMA-2). Ryu et al. (2023b) identify the low-rank nature of delta weights and enhance storage efficiency through low-rank approximation. Alternatively, Liu et al. (2024b) propose a 1-bit quantization approach, termed BitDelta, to further reduce the size of delta weights. They validate the effectiveness of BitDelta across various chat models, including LLAMA-2-CHAT (Touvron et al., 2023) , VICUNA5 , and WIZARDLM (Xu et al., 2023) . In this work, we reassess the performance of both low-rank and low-bit delta-compression methods across a diverse range of aligned LLMs, encompassing mathematical, coding, chat, and multi-modal LLMs. Our experimental results (e.g., Table 3 ) reveal that current low-rank and low-bit compression techniques may significantly degrade the performance of aligned LLMs. These results motivate us to explore more advanced delta-compression methods capable of achieving performance nearly equivalent to the aligned LLMs before compression.Inspired by the long-tail distribution of singular values, as illustrated in Figure 1 , we propose allocating higher-bit representations for singular vectors associated with larger singular values, given their greater impact on the approximation of delta weights prior to compression. Conversely, for singular vectors associated with smaller singular values, we employ low-bit formats to reduce the delta size. For singular values that are extremely small, we omit the corresponding singular vectors altogether. The resulting method, which we term Delta-CoMe, can be viewed as a hybrid of lowrank and low-bit compression techniques. Delta-CoMe outperforms both the low-rank compression method and BitDelta. Moreover, our method achieves performance comparable to that of the full aligned LLMs. For instance, Delta-CoMe attains an average score of 53.2 across eight representative tasks, closely matching the average score of 53.5 achieved by the aligned LLMs. In comparison, the scores of the low-rank and low-bit baselines are 47.8 and 49.3, respectively.Further, we compare the performance of the involved delta-compression methods to LoRA (Hu et al., 2022) , a widely-used delta-tuning approach (Wang et al., 2024) . The primary distinction between delta-compression and delta-tuning is that delta-compression first optimizes the full model and then converts the modified weights into a lightweight module, reducing inference costs in multi-model settings. In contrast, delta-tuning primarily aims to lower training costs. Our experimental results demonstrate that the proposed Delta-CoMe method significantly outperforms LoRA, with scores of 41.9 versus 29.8, respectively. These results suggest that delta-compression can deliver superior performance in multi-model settings compared to delta-tuning.Finally, Delta-CoMe can achieve more than 10× GPU memory and disk storage savings, enabling the deployment of multiple models with limited resources. For practical application, we implement a Triton (Tillet et al., 2019) kernel tailed for Delta-Come, achieving approximately a 3× speedup compared to the PyTorch implementation.Our contribution can summarized as follows:• We propose a mixed-precision delta-compression method that employs varying bit-widths for different singular vectors based on their singular values;• We validate the effectiveness of the proposed method across different types of aligned LLMs of varying sizes, including mathematical, coding, chat, and multi-modal LLMs;• We conduct in-depth analyses to understand the superior performance of our method over low-rank and low-bit baselines. Our method can also outperform delta-tuning approaches such as LoRA, demonstrating that the proposed delta-compression method is more practical for multi-model serving scenarios.• We verify that the proposed method can achieve over 10× saving in GPU memory and disk storage. By constructing a Triton kernel, we can achieve approximately a 3× speedup, demonstrating the hardware compatibility of Delta-CoMe.2 Related WorkQuestion: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?Answer: [Yes] Justification: In the abstract and introduction, we mention that singular values follow a long-tailed distribution. Based on this observation, we propose mixed-precision quantization, assigning more bits to singular vectors corresponding to larger singular values, and provide experimental results.Guidelines:• The answer NA means that the abstract and introduction do not include the claims made in the paper. • The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers. • The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. • It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper. 
delta-compression: 
 Recently, delta-compression has garnered increasing interest in the LLM community due to its ability to substantially diminish the storage and inference expenses associated with serving multiple models. GPT-Zip extends the GPTQ approach (Frantar et al., 2023) to compress the delta weights between aligned models and the backbone model, successfully using 2-bit delta weights to approximate the model. Additionally, they sparsify the quantized delta weights to further reduce storage costs. However, the sparsification technique can hardly reduce GPU memory usage during inference. Similarly, Yu et al. (2024) find that dropping the majority of the delta weights has a limited effect on the performance of aligned LLMs. Ryu et al. (2023a) identify the low-rank property of delta weights and propose reducing the storage requirements of aligned LLMs through low-rank approximation. Yao & Klimovic (2023) adopt the concept of delta-compression to develop a multi-tenant serving system, DeltaZip. Most recently, Liu et al. (2024b) introduced BitDelta, which successfully quantizes the delta weights into 1-bit. However, they only examined the performance of this compression method using chat LLMs, leaving a wide range of other types of aligned LLMs unexplored. In this work, we propose leveraging the benefits of both low-rank and low-bit compression methods by using varying bit-widths to represent different components of the delta weights. We evaluate representative low-rank and low-bit delta-compression methods across various types of aligned LLMs to provide a comprehensive comparison of these methods.Using mixed-precision to compress the model weights is an effective technique that has been investigated in many previous studies. SpQR (Dettmers et al., 2023) isolates a small number of outlier weights and retains them with high-precision, while keeping the other weights at low-precision, resulting in a significant performance improvement. Based on activations, Agile-Quant (Shen et al., 2024) utilizes token pruning to achieve mixed-precision quantization of both weights and activations. Bablani et al. (2023) propose employing varying bit-widths for different layers of the model, while Yao et al. (2021) propose quantizing activations and model weights with different precisions. In this work, we propose using mixed-precision compression for different singular vectors of the delta model, marking the first method to introduce mixed-precision compression for delta weights.3 Approach Question: Does the paper discuss the limitations of the work performed by the authors?Answer: [Yes] Justification: We have elaborated on the limitations in the "Limitation and Broader Impact" section.Guidelines:• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. • The authors are encouraged to create a separate "Limitations" section in their paper.• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. • The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. • The authors should reflect on the factors that influence the performance of the approach.For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. • The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. • If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. • While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations. 
preliminaries: 
 For a backbone LLM θ b , we can customize it into an aligned model θ a for a specific purpose using advanced alignment algorithms (Xu et al., 2023; Luo et al., 2023a; Yu et al., 2023; Luo et al., 2023b; Wei et al., 2023; Liu et al., 2024a) . In some practical scenarios, as mentioned in Section 1, we may need to deploy multiple LLMs at the same time. Formally, we should store and deploy a series of aligned LLMs θ(1) a , • • • , θ (N ) a, where N is the number of aligned models. The total size of the group of aligned models is N × M , where M is the size of one model. We use ∆ to represent the delta weights between the aligned model and the backbone model, which is given byEQUATIONwhere θ (n) is the n-th aligned LLM. Note that the sizes ofEQUATIONa , and θ b are the same.Delta-compression aims to compress the delta weights ∆ (n) into ∆(n) , where the latter has significantly fewer parameters. After delta-compression, we can only maintain one backbone model and N compressed delta models: θ b , ∆(1) , • • • , ∆(N) . The total size is decreased from N × M to(1 + αN ) × M , where α is the compression ratio. During inference, we can restore each aligned LLM in the following way:EQUATIONFor a good delta-compression method, we expect it can achieve a smaller α, while making θ(n) a attain comparable performance with θ (n) a . BitDelta (Liu et al., 2024b) , to our knowledge, is the most recent study that successfully quantizes delta weights into 1-bit, which means that α = 1/16 when the original aligned model is represented by FP16 or BF16. In this work, we propose to improve the performance of delta-compression methods by inducing mixed-precision quantization, which will be detailed in the following sub-sections.Previous works have investigated mixed-precision model compression methods at the token (Shen et al., 2024) or layer level (Bablani et al., 2023) . For delta-compression, we propose employing mixed-precision for different singular vectors. We first use the SVD algorithm to decompose each delta matrix:EQUATIONwhere∆W ∈ R hout×hin , U ∈ R hout×hout , Σ ∈ R hout×hin , V ∈ R hin×hin .Intuitively, the singular vectors associated with larger singular values have a greater impact on the approximation of the delta matrix ∆W, we thus spend more bits for these vectors to reduce the quantization error.Some representative quantization methods, such as GPTQ (Frantar et al., 2023) , aims to minimize the following objective:EQUATION)where X ∈ R hin is the input to the parameter W and Ŵ is the corresponding quantized parameter.We use Quant k to denote the k-bit quantization algorithm. In this work, we employ the widely-used GPTQ method with group_size = 128 for cases where k > 1, and BitDelta for 1-bit quantization. For a certain group of singular vectors, let r begin and r end represent the start and end indices, respectively. The quantization of the singular vectors can be given byV[:, r begin : r end ] ⊤ = Quant k (V[:, r begin : r end ] ⊤ , X), Û[:, r begin : r end ] =Quant k (U[:, r begin : r end ], Σ[r begin : r end , r begin : r end ] V[:, r begin : r end ] ⊤ X).(5)As illustrated in Figure 2 , we use varying quantization bits for different groups of singular vectors. By employing different mixed-precision strategies, we can control the trade-off between achieving a small delta size and maintaining high performance. We will provide more details about the exploration of the mixing strategy in Section 5.1. 
experimental setup: 
 To thoroughly investigate the proposed delta-compression method Delta-CoMe and the involved baselines, we examine the performance of different methods across several tasks, which are typical applications of recent aligned LLMs.Mathematical Problem Solving Solving mathematical problems is a challenging task for modern LLMs. For this task, we employ GSM8K (Cobbe et al., 2021) and MATH (Hendrycks et al., 2021) as the evaluation datasets, which are among the most popular mathematical benchmarks for LLMs. The reported score is accuracy, which is estimated by comparing the ground-truth number with the result calculated by the model.The ability to process code is crucial for numerous practical applications, including data analysis and LLM-based agents. For this task, we use HumanEval (Chen et al., 2021) and MBPP (Austin et al., 2021) as the evaluation datasets, which are widely used in recent studies. The reported score is the pass rate, indicating that the model-generated code can successfully run the test cases in one pass (i.e., pass@1).Chat The chat ability enables LLMs to interact with users, providing helpful and safe suggestions or responses based on the user's requests. A good chat model is expected to be well aligned with human preferences. For evaluating chat LLMs, we select TruthfulQA (Lin et al., 2022) and SafetyBench (Zhang et al., 2023) as the evaluation datasets, which measure helpfulness and safety, respectively. The reported score is the accuracy, indicating that the choice of the model is correct.Multi-Modal Chat Vision-language models (VLMs) are attracting increasing attention due to their ability to process both text and images. Most recent VLMs are based on pre-trained visual encoders and language models, with the language models fine-tuned to understand the visual signal. For this task, we use GQA (Hudson & Manning, 2019) and TextVQA (Singh et al., 2019) . The reported score is the accuracy, indicating that the choice of the model is correct.Table 1 : Selected backbone and aligned models for the examined four tasks.Task 7B Models 13B Models Backbone Aligned Backbone Aligned Math LLAMA-2 WIZARDMATH-V1.0 LLAMA-2 WIZARDMATH-V1.0 Code CODELLAMA-PY MAGICODERS-CL CODELLAMA-PY WIZARDCODER-PY-V1.0 Chat LLAMA-2 LLAMA-2-CHAT LLAMA-2 LLAMA-2-CHAT Multi-Modal VICUNA-V1.5 LLAVA-V1.5 VICUNA-V1.5 LLAVA-V1.5For the four tasks, we provide the backbone and aligned models in Table 1 . All the model weights are open-sourced by the authors. We use both 7B and 13B models to make a thorough comparison between different delta-compression models. During inference, we use greedy search.We employ two representative baselines, including SVD-based low-rank compression and Bit-Delta (Liu et al., 2024b) . For the low-rank baseline, we re-implement the method, while for BitDelta, we use the code open-sourced by the authors. 6 All methods are evaluated on NVIDIA A100 GPUs.5 Experimental Results To determine which bit-width to use and how many singular vectors to quantize, we conduct a preliminary experiment using different mixed-precision strategies. 
exploration of mixed-precision strategies: 
 We examine three types of strategies: single-precision, double-precision, and triple-precision settings. The size of the compressed delta remains consistent across all settings. For single-precision compression, we set r begin to 0, and r end is set to guarantee that the delta size is the same as BitDelta (Liu et al., 2024b) . In other words, the compression ratio α for all settings is 1/16. Formally, for a delta matrix ∆W ∈ R hout×hin , r begin and r end are set to satisfy the following equation:EQUATION)where α is set to 1/16 in our experiments, which is the same as BitDelta. In double-precision settings, r begin and r end are set to 0 and 2, respectively, for the first precision. For the second precision, r begin is set to 2, and r end is adjusted so that the total delta size is 1/16 of the uncompressed delta. In triple-precision settings, r begin and r end are set to 0 and 2, respectively, for the first precision. r begin and r end are set to 2 and 34, respectively, for the second precision. For the third precision, r begin is set to 34, and r end is adjusted so that the total delta size is 1/16 of the uncompressed delta. Since the diagonal matrix Σ occupies little storage, the averaged bit-width for triple-precision compression is approximatelyEQUATIONWe conduct experiments on the math task, and the results are shown in Table 2 . We find that the 3-bit setting performs best among the single-precision settings. Therefore, we keep the 3-bit setting and add other bit-widths to form double-precision settings. Among the double-precision settings, "8+3" achieves the highest score, which is then combined with an additional bit-width to form triple-precision settings. We find that the best double-precision setting can outperform the best single-precision setting, and the best triple-precision setting achieves the highest score across all the examined settings. We use "8+3+2" as the default setting in the following experiments.Tables 3 and 4 show the performance of different delta-compression methods on 7B and 13B models, respectively. Across all tasks, Delta-CoMe outperforms both baselines. While BitDelta (Liu et al., 2024b) can achieve near lossless performance on chat models, it significantly degrades the performance of math and code LLMs, a phenomenon not investigated by Liu et al. (2024b) . Surprisingly, our method achieves good performance in the delta-compression of VLMs. To our knowledge, we are the first to investigate delta-compression for VLMs. To investigate the generalization abilities of the delta-compression methods, we conduct experiments on aligned models based on other representative backbone LLMs. For additional backbones, we utilize MISTRAL-7B-V0.1 (Jiang et al., 2023) and LLAMA-3-8B7 . The corresponding aligned models are OPENCHAT-3.5-0106 (Wang et al., 2023) and LLAMA-3-8B-INSTRUCT, respectively. As shown in Table 5 , our proposed Delta-CoMe method maintains superior performance over the two baselines, demonstrating its generalization ability.A closely related area to delta-compression is delta-tuning. While delta-tuning primarily aims to reduce the training cost of LLMs, delta-compression focuses on reducing the storage and inference cost for multi-model serving. It remains unclear whether delta-compression outperforms delta-tuning when using the same delta size. To investigate this, we trained LoRA (Hu et al., 2022) modules for all model parameters to compare delta-compression with delta-tuning. We set the LoRA rank to 128 and the scale factor to 16, using a cosine warmup schedule with a warmup ratio of 0.04 and a peak learning rate of 1e-4. For each task, we trained the LoRA for 3 epochs. Table 6 shows the results of both delta-tuning and delta-compression methods. The results reveal that LoRA achieves superior performance compared to the low-rank compression approach and BitDelta in the mathematical task. However, when it comes to the coding task, LoRA exhibits lower performance than both low-rank compression and BitDelta. By contrast, our proposed delta-compression method (i.e., Delta-CoMe) consistently outperforms LoRA across all four benchmarks. Specifically, the performance of our method is close to that of the uncompressed aligned models (41.9 vs. 43.0), while the average score of LoRA is only 29.8. These results imply that learning an aligned model and then compressing it can achieve better results than delta-tuning.For practical applications, we also examine the inference speed and memory cost of Delta-CoMe.In terms of inference speed, we implement a Triton kernel. Figure 3 shows the inference time of the PyTorch and Triton implementation of Delta-CoMe. Overall, we can achieve approximately a 3× speedup across different settings. As Figure 3a shows, we first conduct an ablation experiment on varying batch sizes. Our implemented Triton kernel is consistently faster than the PyTorch implementation with different batch size settings. As Figure 3b depicts, we conduct an ablation experiment on hidden size to verify the adaptability of the Triton kernel to models of different sizes.The Triton kernel can maintain a substantial speedup across different hidden sizes, demonstrating its ability to adapt to various models. In Table 7 , we show the GPU memory cost of deploying multiple aligned models that are fine-tuned from LLAMA-2-7B. The model parameters are represented in BF16 on a single 80G GPU. Without delta compression, a single GPU can not support 8 models, let alone more models. Using our proposed delta-compression method, we can load up to 50 models into one GPU, significantly reducing the deployment cost.6 AnalysisQuestion: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?Answer: [No] Justification: We will open-source all resources once the paper is de-anonymized.Guidelines:• The answer NA means that paper does not include experiments requiring code. • Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted. 
analysis of quantization error: 
 To better understand the performance of various delta-compression methods, we estimate the quantization error as defined in Eq. ( 4). It is important to note that the error we calculate differs from that of GPTQ. Specifically, we use the mean square error between the activations of the uncompressed aligned model and those of the combination of the backbone model and the compressed delta model. The error is estimated on the GSM8K test set using WIZARDMATH-7B-V1.0 as the aligned model and LLAMA-2-7B as the backbone model. Since different layers have varying impacts on the final output (Wu et al., 2023) , we distinguish low-, medium-, and high-layers when estimating the average quantization error. Specifically, the first 11 layers are designated as low-layers, the 12th to 22nd layers as medium-layers, and the last 10 layers as high-layers. Moreover, as outliers play a critical role in model compression (Dettmers et al., 2023; Lin et al., 2023) , we also calculate the average error on outlier parameters. For each delta matrix ∆W, we select the top 1% of columns with the largest absolute values as outliers. Table 8 presents the results. We find that the average error of our methods (i.e., "Single" and "Triple") is substantially lower than both the low-rank baseline and BitDelta. Furthermore, the error of "Triple" is consistently less than that of "Single," reaffirming the necessity of mixed-precision compression for delta weights.We also present a detailed case study in Figure 4 . Three delta-compression methods are examined: BitDelta, single-precision compression, and triple-precision compression. The reference answer is "104 hours". We observe that BitDelta makes mistakes initially, while single-precision compression generates an incorrect intermediate result at the second reasoning step. In contrast, our mixedprecision delta-compression method calculates the correct final answer. First, We know that she wrote 2/5 times more articles on Tuesday than on Monday. Therefore, the number she wrote on Tuesday is 2/5 * 5 = 2 articles more than on Monday. Thus, the total number on Tuesday is 5 + 2 = 7 articles. We know that she wrote twice the number of articles she wrote on Tuesday. Therefore, the number on Wednesday is 2 * 7 = 14 articles. The total number of articles is 5 + 7 + 14 = 26 articles. the total number of hours she spent writing articles in the three days is 26 * 4 = 104 hours. Therefore, the final answer is 104 hours.Triple-Precision " Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?Answer: [Yes] Justification: In the experiment section of our paper, we provide a setup subsection that details our experimental settings.Guidelines:• The answer NA means that the paper does not include experiments.• The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. • The full details can be provided either with the code, in appendix, or as supplemental material. 
conclusion: 
 In this paper, we propose Delta-CoMe, a delta-compression method with mixed-precision inspired by the long-tail distribution of singular values in the delta weights. Delta-CoMe achieves near-lossless performance compared to uncompressed aligned models across various typical tasks, including math, code, chat, and multi-modal tasks. We validate the effectiveness of Delta-CoMe on several widelyused aligned LLMs, whose backbone pre-trained models include Llama-2, Llama-3, and Mistral. Experimental results demonstrate that Delta-CoMe outperforms several representative baselines by a considerable margin. We believe the newly introduced Delta-CoMe method has significant value for many practical applications, such as multi-tenant serving.Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?Answer: [No] Justification: The proposed delta-compression method does not rely on any randomness.Repeatedly run the proposed algorithm can always yield the same compressed delta weights. We thus did not conduct statistical significance tests in our experiments.Guidelines:• The answer NA means that the paper does not include experiments.• The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.• The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors).• It should be clear whether the error bar is the standard deviation or the standard error of the mean. Justification: Delta-CoMe can efficiently compress and deploy multiple models on a single GPU, saving the original computational cost and reducing carbon emissions. Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?Answer: [NA] Justification: In this paper, our main contribution is proposing a novel compression algorithm.We have not released any potentially harmful models or data.Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?Answer: [Yes] Justification: We can ensure that we have cited correctly.Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.• If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. • For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. • If this information is not available online, the authors are encouraged to reach out to the asset's creators. 13. New Assets Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets? Answer: [NA] Justification: this paper does not release any new datasets or models. Guidelines:• The answer NA means that the paper does not release new assets.• Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. • The paper should discuss whether and how consent was obtained from people whose asset is used. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review. 
 
 Appendix: For limitations, on the one hand, we carried out extensive experiments to verify Delta-CoMe is near lossless in delta compression. However, we haven't explored mixed-precision in model compression. Recently, mixed-precision is applied widely in model compression and Delta-CoMe can provide a new perspective for model compression. On the other hand, our kernel is trivial, Wei et al. (2024) and Guo et al. (2024) have implemented more advanced kernels. We can draw on their methods to achieve higher acceleration ratios.For broader impacts, this paper presents Delta-CoMe that mainly focuses on compression which can not only boost efficiency but also save GPU memory, may bring benefits to society.In Section 5.2, we have elaborated on the setting of different bits. All our models employ the same configuration and have demonstrated near loss-less performance, which illustrates robustness.Allocating different numbers to different bits (e.g. 16-bit, 8-bit) is a multi-objective optimization problem. We implemented a genetic algorithm to achieve a more fine-grained search. We use the following objective function,f = min PPL(x 1 , x 2 , x 3 , x 4 , x 5 )where x 1 , x 2 , x 3 , x 4 , x 5 indicating the number of means we calculate perplexity using samples randomly chosen form C4 dataset. Table 9 illustrates the results, particularly in code tasks, where genetic search shows a significant improvement compared to greedy search. The average performance of genetic search across all tasks even surpasses that of the original half-precision models. However, the time and storage overhead of genetic search is much greater than that of greedy search. Quantization methods (e.g., GPTQ, AWQ) have been widely used for quantizing backbones. It is of great significance for us to verify whether Delta-CoMe can still maintain good performance in low-bit backbone scenarios.We evaluated the performance of Delta-CoMe using various backbones across multiple tasks in Table 10 . We utilized GSM8K for math tasks, MBPP for code, TruthfulQA for chat, and TextVQA for multi-modal tasks. Table 10 has demonstrated that even when backbones are in low precision, Delta-CoMe can achieve performance similar to the original, indicating that Delta-CoMe can be further applied to backbones of various precision levels.We have shown that Delta-CoMe can maintain near lossless performance under a 16× compression ratio. In the following, we attempt to explore the compression limits of Delta-CoMe. We employhttps://chatgpt.comhttps://lmsys.org/blog/2023-03-30-vicunahttps://github.com/FasterDecoding/BitDelta.https://huggingface.co/meta-llama/Meta-Llama-3-8B. 


Decision: This paper presets a novel approach to apply delta-compression for aligned language models (from pretrained and finetued language models). The proposed approach try to combine the existing low-rank and low-bit compression methods together to achieve better performance. More specially, the approach applies mixed precision quantization for different SV based on their values. All reviews agree the paper is novel and the experiments indeed show the merit of the proposed approach.

Reviews: review: paper_summary: paper_summary: This paper introduces Delta-CoMe, a delta compression method for LLM. It proposes to combine low-rank compression and low-bit compression together to achieve better performance. Specifically, it applies mixed-precision quantization for different singular vectors based on their singular values. The experimental results demonstrate good performance of the proposed method.
strength_weakness: strength_weakness: 1. The bit-width in mixed-precision seems to be a multi-objective optimization problem, and the authors adopt a greedy search in this paper. In Table 2, different settings vary a lot in performance. This suggests that it requires to decide the bit-width carefully, making the method not easy to generalize well to other tasks/models. Performance may not be guaranteed before doing a search.
2. The value of $r_{begin}$ and $r_{end}$ seem to be set intentionally and empirically without explanation or study. This would also impact the generalization of the method.
questions: questions: 1. In equation 5, why the quantization of $V$ is $Quant_k(V, X)$ without $U$ and $\Sigma$ as in the quantization of $U$?
2. In Section 5.1, how are $r_{begin}$ and $r_{end}$ set to those values?
limitations: limitations: N/A
paper_summary: paper_summary: This paper proposes an improved way to apply delta-compression for aligned language models (compact representations of the difference in weights between the pretrained and finetuned language models), which is just as effective w.r.t compression as the most extreme existing binary quanitzation strategy (BitDelta), but resolving many existing quality issues w.r.t. math and code tasks over previous methods. The key insight is that it is possible to combine the best of both worlds between low-rank methods (selecting the top singular values) and quantization methods (e.g. BitDelta), and represent more singular values by using decreasing precision for decreasing singular values: a mixed precision technique overall. The authors call this technique Delta-CoMe. When comparing low-rank, BitDelta, and Delta-CoMe at a fixed compression rate (equal to the binarization / BitDelta rate, which is quite aggressive), Delta-CoMe consistently outperforms all baselines and is close to matching performance with the full precision aligned model. Experiments take place over a diverse set of tasks (math, code, QA, safety, multimodal) as well as a diverse set of models at 7B and 13B scales and aligned versions (Llama 2, WizardMath, MagicCoders, Llama-2-Chat, LLAVA v1.5, OpenChat, Llama-3-8b-Instruct). The authors also provide quality comparisons between delta-compression methods and delta-tuning (i.e. LoRA), demonstrating that Delta-CoMe outperforms LoRA w.r.t quality.
strength_weakness: strength_weakness: 1. In Table 4, it does seem like on the larger 13B models WizardMath models, the performance recovery in GSM8k and MATH is not as strong as on 7 or 8B scale models. It does bring into question whether there are limitations to this approach not discussed in this work that may limit general adoptability. Whether that means not working as well on larger scales, or for the certain type of post-training happening in WizardMath. 

1. Although I understand the author's motivation of using greedy decoding to encourage reproducibility and decrease noise in the evaluations, many models especially on chat tasks use sampling based-decoding, and having results here would improve the overall robustness of the experiments to verify that the techniques still work well. 

1. Presentation a couple points in the paper could be improved :

    a. While the authors do note that the greedy search strategy to allocate mixed-precision to the singular values presented in Section 5.1 represents a proof of concept to show that even such an unoptimized approach can achieve good results, it would be valuable to understand how some of the design choices here were informed. For example, in the 3-precision setting, the range of singular vectors for the 2nd precision is set to be between 2 and 34, which feels arbitrary. What is the intuition behind this or were there ablations ran here? Being that Section 5.1 is the core description of the mixed-precision strategy, more detail and clarity here would be appreciated.

    b. (Minor) The introduction could be cleaned up a bit, with lines 21-36 being oddly detailed. The claim on line 44-46 to motivate the work is also not super well founded -- there are models on LMSys showing general ability with ~20B parameters, not too much bigger than those considered in this work.
questions: questions: 1. What is the intuition behind choosing the singular vector bands for the different precisions the way that you do in Section 5.1?

1. Do you think the ideas here could apply to mixed-precision approaches more generally?

1. Why is the approach named Delta-CoMe? It appears to stand for delta compression method which seems very generic? And has nothing to do with the details of the approach. 

1. Are there any practical limitations e.g. hardware with mixed-precision delta-compression not covered in this paper?
limitations: limitations: The authors do clearly point out that a major limitation of the work is the lack of optimization for how the mixed precision is assigned. This makes the approach more of a proof of concept that even a naive solution works, rather than an optimized method. This is perfectly fine.

It would be valuable to understand though whether theres actually limitations in deploying this type of approach on actual hardware with multi-tenant hosting. 

It would also be interesting to understand the boundaries to when this approach works or does not work, e.g. at what compression ratio would it break, whether theres a model scale too small or too large, etc.
paper_summary: paper_summary: In the context of SVD compression of delta weight, the paper employs higher bitwidth for singular vectors corresponding to larger singular values. The available bitwidth 8, 3, 2 are empirically chosen. Once the bitwidths are assigned to the singular vectors, the vectors are group-wise quantized by GPTQ.
strength_weakness: strength_weakness: Something is wrong with the latex encoding of this pdf. Sections are not detected properly by pdf readers, and there are odd reference errors such as the ones on line 26 and 30. 

There are three steps of optimization being done: the number of largest singular vectors chosen, the bitwidth assigned to the singular vectors, and the quantization algoritm performed on the singular vectors. In the paper, the three steps are being done sequentially, leading to arbitrary, empirically-driven and possibly suboptimal decisions.
questions: questions: Why is there an advantage to SVD the delta weights as opposed to SVD the aligned model weights directly?
limitations: limitations: Yes
paper_summary: paper_summary: This paper proposes an application of the mixed precision quantization technique to the singular vectors of the delta weights, which is encountered when serving multiple aligned LLMs.
strength_weakness: strength_weakness: Please see the “Questions” section.
questions: questions: My review is as follows:

1) As a strength, this paper is well-written and makes it easy for the reader to follow the ideas.
2) The proposed method is a somewhat straightforward extension of mixed precision quantization to the singular vectors of the delta weights. The mixed precision quantization technique is well-known and commonly used by practitioners. I view the contribution of this paper as an extension of that. Because of that, I am not sure if the contributions of the paper could be considered novel. Having said that, it is good to see that the method performs well in multiple scenarios. 
3) I understand that studying the compression of delta weights is important. In practice, the base model’s weights need to be quantized/compressed too for real-world situations. I don’t think the compression of base model weights and delta weights are completely orthogonal. I wonder what the authors think on the interdependency of the compression of base model weights and delta weights. In my opinion, it would improve the paper to include some results/discussion on this.
4) I’m wondering why the authors haven’t considered a more thorough search algorithm in Section 5.1 (or if they did, it would be great to include a discussion on it). 

Minor:

5) Typo in Table 1: “Aligend”
6) Typo in Table 6: “HuamnEval”
limitations: limitations: Yes.

Comments: title: Invitation to Join the Discussion Period
Response
Invitation to Participate in the Discussion Period
Invitation to Participate in the Discussion Period
Performance on hardwares
comment: Thank you very much for your insightful suggestions. We have provided detailed responses to your question. If you have any other questions, we sincerely invite you to participate in the discussion period if possible. Thanks very much!
Thank you authors for providing the wealth of additional results. I strongly urge the authors to update the manuscript in future versions or camera ready with these additional results, as I do really think that the work greatly benefits from it. With this being said I would like to keep my score at this time -- which genuinely represents a well executed and empirically sound work that is valuable and I believe should be accepted to the conference. Only limitations from a higher score would be regarding the scope and size of the contribution of the work.
Thanks for the detailed answers to my questions. The new results are helpful. I'm however still on the fence about whether the novelty of this approach is substantial enough for a neurips paper.
Dear Authors, My concerns have been addressed accordingly. I have raised my score to 6 and confidence to 4.
Thank you very much for your insightful suggestions. We have provided detailed responses to your question. If you could participate in the discussion period, we would be very grateful.
Thank you very much for your insightful suggestions. We have provided detailed responses to your question. If you could participate in the discussion period, we would be very grateful.
To accelerate the inference of our proposed method, we implemented a computation kernel using Triton, which integrates the de-quantization process with matrix multiplication. This kernel supports the multiplication of matrices with different bit-widths.
By using our customized Triton kernal, we can significantly improve the forward speed of Delta-CoMe:

Ablation on batch, we set sequence length to 128, our method achieves 3x speedup than Pytorch.
| bsz | Delta-CoMe w/ PyTorch (ms) | Our Customized Triton Kernal (ms)|
|-----|-------------|----------|
| 2   | 0.5995      | 0.1488   |
| 4   | 0.6024      | 0.1995   |
| 6   | 0.6136      | 0.2134   |
| 8   | 0.6656      | 0.2561   |

Ablation on hidden_size, we set batch 8.

| hidden_size | Delta-CoMe w/ PyTorch (ms) | Our Customized Triton Kernal (ms) |
|-------------|--------------|----------|
| 1024        | 0.5369       | 0.1206   |
| 2048        | 0.5586       | 0.1654   |
| 3072        | 0.6011       | 0.2046   |
| 4096        | 0.6656       | 0.2561   |
| 5120        | 0.6897       | 0.2788   |
Further, Han Guo et al. and Jianyu et al. have implemented more advanced kernels. We can draw on their methods to achieve higher acceleration ratios.

To further demonstrate the hardware advantages of our method, in addition to inference speed, we have also provided memory usage in the table below.
| Num. deployed models | Original Storage | Our Storage |
|-----------------|------------------|-------------|
| 2               | 26.67G           | 15.39G      |
| 4               | 52.24G           | 17.02G      |
| 8               | OOM              | 20.28G      |
| 16              | OOM              | 26.79G      |
| 32              | OOM              | 39.84G      |
| 64              | OOM              | 66.68G      |
Our method can save GPU memory significantly.