WorksComputer Science
Quantization of Large Models with Weight Outliers and Sparsity
Abstract
Post-training quantization (PTQ) reduces the memory burden of large model deployment by casting the high precision trained weights to fewer bits. While this promotes memory-efficient inference, it also incurs quantization error that impairs model performance. To compensate for quantization error, the present contribution decomposes the original trained weights into a quantized matrix, a low-rank component, and a sparse matrix that accounts for outlier rows in the weights. Due to analytical intractability and the discrete structure of the decomposition, a simulated annealing search is employed to explore candidate decompositions while avoiding poor local minima. Numerical tests demonstrate the effectiveness of this approach across a broad suite of large language models, including Llama 3.2 1B, Llama 3.2 3B, Llama 3.1 8B, and Qwen2.5 7B, evaluated on natural language generation benchmarks using 4-bit NF4 and FP4 quantizers. The novel method can markedly outperform direct quantization while incurring minimal memory overhead.
Introduction
Large language models (LLMs) [1, 2] have demonstrated remarkable effectiveness across a wide range of tasks, including natural language understanding [3], code generation [4], and reasoning [5]. Underpinning these capabilities are models with billions of parameters, typically represented in 16-bit floating-point formats (e.g. FP16, BF16). Although training such models requires substantial computational and energy resources, this process is typically performed once. In contrast, the subsequent LLM deployment requires sustained memory and bandwidth throughout the model’s lifetime. As models scale, memory-efficient deployment has become an increasingly important challenge, particularly in resource-constrained and latency-sensitive environments such as edge devices and the cloud.
To address this, several model compression techniques have been advocated. For example; pruning [6] reduces the parameter count by removing weights; knowledge distillation [7] transfers knowledge to a smaller student model; and quantization [8, 9] maps model parameters to lower-precision numerical formats. Among these approaches, low-bit quantization is particularly attractive because it can markedly curtail memory footprint and bandwidth requirements.
Post-training quantization (PTQ) is a popular paradigm because it applies quantization to a model after training, as opposed to alternative paradigms that incorporate quantization during pretraining [10] or fine-tuning [11]. Conventional PTQ typically leverages a calibration dataset to determine the quantization parameters [12, 9], whereas zero-shot PTQ directly quantizes model parameters without additional data. This distinction establishes zero-shot PTQ as remarkably attractive in scenarios where representative calibration data is unavailable. However, a central challenge in PTQ is coping with the associated quantization error, especially when compressing to 4 bits or less. For LLMs, the performance impairment can be exacerbated because errors propagate in the transformer layers and across output tokens in long-sequence inference [8, 13].
A major source of quantization error is the presence of high-magnitude outliers in LLM weight distributions, which can exhibit structured patterns [8, 13]. Directly quantizing such outliers is challenging because they enlarge the quantization range and thereby reduce quantization fidelity for the majority of weights, especially in low-bit regimes. As a result, outliers can contribute disproportionately to quantization error and lead to downstream performance degradation. Prior work has proposed several strategies to mitigate this issue. For instance, Gpt3.int8() [8] and SPQR [13] isolate high-magnitude activation or weight outliers and retain them in higher precision. SmoothQuant [14] transfers activation outliers to weights using per-channel scaling, while AWQ [15] performs saliency-aware weight quantization. QuaRot [16] instead applies rotation matrices to redistribute activation magnitude. Many of these approaches, however, rely on calibration data and can thus be less suitable in fully calibration-free/zero-shot deployment settings.
Rather than directly quantizing pretrained weights, we adopt a calibration-free mixed-precision decomposition framework that factorizes high-precision pretrained weights into three complementary components: a quantized backbone, a high-precision sparse component, and a high-precision low-rank factor. This decomposition is motivated by the observation that, once the high-energy outliers are isolated, the remaining reconstruction error often admits an efficient low-rank approximation capturing the dominant singular directions. Together, the sparse and low-rank components improve reconstruction fidelity while incurring minimal memory overhead and inference latency. Since a global search for an optimal decomposition scales exponentially with weight matrix dimensions, the present contribution leverages a simulated annealing algorithm to explore candidate decompositions while avoiding poor local minima. Experiments on zero-shot natural language generation tasks demonstrate the effectiveness of the proposed approach across a wide range of popular large language models quantized to 4-bit NF4 and FP4 formats.
Preliminaries
Consider a general weight matrix from a pretrained model stored in 16-bit floating-point precision. To reduce the memory footprint during deployment, a quantizer maps entries of onto a finite -bit codebook and stores the resulting low-precision representation in memory. The stored values are converted back to a higher-precision compute format on the fly through a dequantizer . The overall quantize-then-dequantize operator is denoted by , which is not an identity mapping owing to quantization error. Accordingly, the quantization error is , whose magnitude depends on both the quantizer design and the distribution of the weight entries.
A representative example is normal float (NF) quantization [17] that constructs a codebook with a standard Gaussian prior for the weight entries. Letting denote the quantile function of the standard Gaussian distribution , the normalized -bit NF codebook is defined by

Figure 1. From left to right: squared row norms of the quantization error (NF4, block size 64) for the pretrained query, down, and output projection matrices of Llama 3.1 8B, plotted against layer depth. The quantization error exhibits structured high-energy outlier rows across several layers.
Given a scaling factor , the reconstruction is obtained via a nearest-neighbor solution in the normalized domain followed by rescaling
That is, the high-precision weights are first normalized to , quantized to the nearest codebook level, and then mapped back to the original range by scaling with the largest absolute entry of the original weights. In low-bit regimes such as 4-bit quantization, NF4 (i.e. the 4-bit instance of NF quantization) has become a popular choice as it can yield lower quantization error than integer or floating-point alternatives. In practice, the weight matrix can be partitioned into non-overlapping blocks of equal size with scaling factor assigned block-wise. While this fine-grained approach can account for variation in weight magnitude, quantization remains sensitive to large-magnitude outliers, which can degrade the quantization fidelity around the majority of small weights.
Pretrained LLM weights, specifically, are observed to exhibit both entry-wise and row-wise outliers, i.e., entire rows with significantly larger entries. This outlier pattern propagates to the quantization error as well, even if quantization is performed block-wise. Figure 1 displays the row-wise energy of the quantization error for the Llama 3.1 8B pretrained weights against layer depth. Direct NF4 weight quantization was applied with a block size of 64 elements. The figure corroborates that outliers concentrate in a small subset of rows, particularly in the multi-layer perceptrons (MLP) of the transformer blocks. Orthogonally, the quantization error can be effectively captured by a low-rank approximation. Although is typically high-rank, it is observed that the leading singular values can be significantly larger than the remaining spectrum [18]. Prior work [19] has also explored low-rank structure in the quantization error, albeit in a LoRA fine-tuning setting. In contrast, this work investigates outlier-aware zero-shot PTQ, where calibration or fine-tuning data may be unavailable. This motivates a co-design of outlier modeling and low-rank approximation for quantization error.
Notation. Calligraphic uppercase letters denote sets. Bold uppercase letters denote matrices, while bold lowercase characters, vectors. For some matrix , denotes its -th row, denotes the Frobenius norm, and counts the number of nonzero rows. The symbol denotes function composition, and denotes the rank- truncated SVD approximation of . The symbol is the indicator function, while denotes the hard thresholding function that preserves the highest energy rows of , while setting the rest to .
Outlier-aware zero-shot PTQ via simulated annealing
To cope with the quantization error under row outlier patterns, this paper advocates decomposing the trained weights into a quantized matrix , a row-sparse matrix , and a low-rank matrix with rank . This mixed-precision decomposition of can be captured via the discrete optimization problem
where , and . Although the cost function in (1) is analytically tractable, the caveat is that the search space induced by has cardinality . This renders an exhaustive combinatorial search for computationally intractable with and given. An alternative is to adopt block coordinate descent solvers cycling between each component. However, such methods are prone to poor local minima in this highly non-convex and discrete search space, and lack a principled mechanism for global exploration.
To address this limitation, this paper adopts a meta-heuristic simulated annealing algorithm, which performs a search over candidate decompositions using temperature-controlled random perturbations.
The temperature follows a pre-defined schedule that decreases over time, thus encouraging exploration of the quantized matrix set to expose non-local but potentially superior candidates.
Specifically, the quantized backbone is initialized as the direct quantization , and the row-sparse component is initialized as . Given a decreasing temperature schedule (e.g. linear, geometric, cosine), the simulated annealing search generates proposals
for . is sampled from a pre-specified prior , which can be a Gaussian distribution with standard deviation scaled by , for instance. This perturbation in the low-rank component encourages exploration of in regions where the error is approximately low rank while avoiding being trapped around the current iterate . The cost of the current proposal is , and the next iterate is taken as
where the acceptance probability is . Note that a better proposal is always accepted, but a nominally worse proposal can be accepted with probability , enabling the trajectory to escape sub-optimal local minima. The algorithm outlining this procedure can be found in section A of the Appendix.
At the final iteration , the algorithm outputs a quantized matrix , together with high-precision row-sparse and low-rank components and , corresponding to the final accepted iterate. To reduce the additional memory and compute cost of storing the high-precision components densely, the row sparsity of is exploited and the low-rank component is factorized with truncated rank- SVD. In particular, writing , the low-rank component is stored through the factors and where . The row-sparse component is stored only through its nonzero rows and their indices. Letting denote the index set of kept rows, with , this reduces the storage of from to high-precision entries along with the negligible row indices. Therefore, for an input , the per-matrix inference becomes , where the term can be evaluated only on the rows indexed by .
Numerical Tests
This section assesses the proposed zero-shot PTQ method on Llama 3.2 1B, Llama 3.2 3B, Llama 3.1 8B, and Qwen 2.5 7B models, which are evaluated with the LM Evaluation Harness API [20] on GSM8K [21], MBPP [22], and WikiText-2 [23] datasets. Direct quantization, LoFTQ initialization [19], and the proposed method are compared under both NF4 [17] and FP4 quantization. All experiments use a rank for , and annealing iterations. To control the row sparsity, a percentage-wise row budget is defined a-priori, where . Both (i.e. ) and are evaluated. The decomposition is applied to all transformer attention and MLP projections (i.e. q_proj, k_proj, v_proj, o_proj, up_proj, down_proj, and gate_proj). Projections of the same type share a common geometrically decreasing annealing temperature schedule, obtained from a Bayesian optimization pre-processing step (cf. [24]). A single NVIDIA A100 40GB GPU is employed for all tests.
The results are summarized in Table 1, comparing direct zero-shot quantization, the LoFTQ initialization, annealing without row sparsity (), and the proposed row-sparse annealing method with . Although LoFTQ [19] was originally proposed for LoRA-aware quantization, we include it as a baseline under the same zero-shot PTQ evaluation protocol. Across NF4 and FP4 quantization, the proposed row-sparse plus annealing method achieves the best or near-best performance in most settings, and the gains are especially consistent on WikiText-2, where it obtains the lowest perplexity for every model and quantization format except for the NF4 Llama 3.2 3B case. This suggests that explicitly modeling row-structured outliers can better preserve language-modeling performance under low-bit quantization. In GSM8K, it improves over direct quantization in all cases and typically outperforms both the LoFTQ initialization and annealing without row sparsity, indicating that the sparse correction is beneficial for preserving mathematical reasoning performance under low-bit quantization.
Table 1: Performance comparison on NLG benchmarks using select Llama 3 models and Qwen 2.5 7B. Word perplexity is reported on WikiText-2 (WT-2), while GSM8K and MBPP report exact-match accuracy and pass@1 code-generation accuracy, respectively. Higher is better for GSM8K and MBPP, while lower is better for WT-2.
| Model | Method | NF4 GSM8K (↑) | NF4 MBPP (↑) | NF4 WT-2 (↓) | FP4 GSM8K (↑) | FP4 MBPP (↑) | FP4 WT-2 (↓) |
| Llama 3.1 8B | Original (FP16) | 50.27 | 47.60 | 7.55 | 50.27 | 47.60 | 7.55 |
| Llama 3.1 8B | QLoRA init. | 44.73 | 47.00 | 8.04 | 38.29 | 43.40 | 8.51 |
| Llama 3.1 8B | LoftQ init. | 44.12 | 44.80 | 7.98 | 38.67 | 44.20 | 8.39 |
| Llama 3.1 8B | Ours | 44.96 | 46.80 | 7.93 | 42.68 | 45.60 | 8.32 |
| Llama 3.1 8B | Ours | 46.32 | 48.00 | 7.89 | 43.97 | 46.40 | 8.31 |
| Qwen 2.5 7B | Original (FP16) | 83.40 | 63.40 | 8.74 | 83.40 | 63.40 | 8.74 |
| Qwen 2.5 7B | QLoRA init. | 78.70 | 61.40 | 9.09 | 79.76 | 62.40 | 9.61 |
| Qwen 2.5 7B | LoftQ init. | 79.91 | 62.60 | 9.06 | 79.38 | 61.80 | 9.47 |
| Qwen 2.5 7B | Ours | 81.50 | 60.00 | 9.01 | 77.03 | 57.40 | 9.31 |
| Qwen 2.5 7B | Ours | 82.49 | 62.80 | 9.01 | 80.14 | 62.20 | 9.30 |
| Llama 3.2 3B | Original (FP16) | 27.45 | 38.60 | 9.51 | 27.45 | 38.60 | 9.51 |
| Llama 3.2 3B | QLoRA init. | 22.52 | 32.60 | 9.98 | 18.73 | 33.40 | 10.42 |
| Llama 3.2 3B | LoftQ init. | 21.53 | 34.20 | 9.93 | 19.03 | 35.00 | 10.30 |
| Llama 3.2 3B | Ours | 24.72 | 37.80 | 9.83 | 19.56 | 36.00 | 10.20 |
| Llama 3.2 3B | Ours | 23.58 | 35.00 | 9.86 | 22.21 | 31.60 | 10.18 |
| Llama 3.2 1B | Original (FP16) | 5.61 | 26.60 | 8.07 | 5.61 | 26.60 | 8.07 |
| Llama 3.2 1B | QLoRA init. | 2.81 | 18.40 | 13.06 | 1.36 | 13.40 | 14.28 |
| Llama 3.2 1B | LoftQ init. | 3.71 | 21.60 | 12.92 | 2.27 | 10.20 | 13.77 |
| Llama 3.2 1B | Ours | 3.94 | 19.40 | 12.73 | 2.20 | 15.40 | 13.49 |
| Llama 3.2 1B | Ours | 4.70 | 22.20 | 12.69 | 2.65 | 15.20 | 13.42 |
Table 1.
For code generation with MBPP, our methods achieve the best pass@1 score for NF4 quantization across all four models. With FP4, however, plain quantization is slightly better on Qwen 2.5 7B, and annealing without row sparsity performs better on Llama 3.2 3B and Llama 3.2 1B. This could suggest that the benefits of the low-rank and row-sparse corrections can overlap, and the design choice of explicit outlier modeling depends on the model, task, and structure of the quantization error. Overall, the results support that annealing-based decompositions improve over alternative approaches, and adding row-sparse outlier absorption can boost gains with minimal storage overhead (cf. Appendix § 7), particularly for perplexity and GSM8K accuracy.
Conclusion and future work
This paper introduced a calibration-free post-training quantization method that decomposes pretrained LLM weights into quantized, low-rank, and row-sparse components. By explicitly modeling row-structured outliers in the weights, the proposed decomposition improves zero-shot performance over direct quantization and low-rank alternatives across several models and quantization formats. These results suggest that mixed-precision decompositions can be beneficial for low-bit PTQ, particularly when calibration data or fine-tuning data is unavailable. Future work will investigate using the low-rank factors as an initialization for LoRA fine-tuning, exploring whether zero-shot performance correlates with downstream adaptation capacity.
Algorithm pseudocode
This Appendix section provides the pseudocode of the present contribution in Algorithm 1. The algorithm inputs are the pretrained high-precision weights , the number of annealing steps , the rank of the low-rank component , the sparsity-controlling parameter for the row-sparse , and the temperature schedule . While the temperatures are geometrically decreasing, alternative schedules such as cosine or linear can be readily employed. Another design choice concerns the perturbation distribution, which in this work is defined as a zero-mean Gaussian with standard deviation proportional to the temperature. We leave alternative schedule and perturbation design choices for future research.
Algorithm 1 Simulated annealing solver for quantized, low-rank, and row-sparse decomposition
Input: , , , , ,
Initialize: , ,
for do
sample ,
sample
if then
else
Output: , ,
Memory overhead analysis
The memory overhead is measured in bits per parameter, and is calculated for all seven attention and MLP projection types in every layer. The low-rank components and are stored in FP32 and employ a rank . The non-zero rows of each row-sparse matrix and their indices are stored in FP16 and FP32 respectively. For both the NF4 and FP4 quantization schemes, one FP32 scaling factor is used per block of 64 weights without double quantization. The remaining parameters are stored in FP16. Table 2 provides a summary of the results.
| Model | Original (FP16) | QLoRA init. | LoftQ init. | Ours | Ours |
| Llama 3.1 8B | 16.000 | 6.005 | 6.339 | 6.339 | 6.477 |
| Qwen 2.5 7B | 16.000 | 6.146 | 6.486 | 6.486 | 6.621 |
| Llama 3.2 3B | 16.000 | 5.911 | 6.395 | 6.395 | 6.533 |
| Llama 3.2 1B | 16.000 | 6.945 | 7.529 | 7.529 | 7.653 |
Table 2. Memory storage comparison across quantization schemes in bits per parameter. Values apply to both NF4 and FP4 quantization schemes.
At a rank of , our method with incurs an additional 0.12–0.14 bits per parameter relative to the or the alternating optimization cases. These estimates include quantization scales and row indices.
References
- [1]Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, et al., “Mistral 7B,” arXiv:2310.06825, 2023.arxiv.org/abs/2310.06825
- [2]Aaron Graffiatiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al., “The Llama 3 herd of models,” arXiv:2407.21783, 2024.
- [3]Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman, “SuperGLUE: A stickier benchmark for general-purpose language understanding systems,” in Proc. Neural Information Processing Systems (NeurIPS), 2019.arxiv.org/abs/1905.00537
- [4]Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al., “Evaluating Large Language Models Trained on Code,” arXiv:2107.03374, 2021.arxiv.org/abs/2107.03374
- [5]Yonatan Bisk, Rowan Zellers, Ronan Le Bras, Jianfeng Gao, and Yejin Choi, “PIQA: Reasoning about Physical Commonsense in Natural Language,” Proc. AAAI Conf. Artif. Intel., 2020.arxiv.org/abs/1911.11641
- [6]Saleh Ashkboos, Maximilian L. Croci, Marcelo Gennari do Nascimento, Torsten Hoefler, and James Hensman, “SliceGPT: Compress large language models by deleting rows and columns,” in Proc. Int. Conf. on Learning Representations (ICLR), 2024.arxiv.org/abs/2401.15024
- [7]Luyang Fang, Xiaowei Yu, Jiazhuang Cai, Yongkai Chen, Shushan Wu, Zhengliang Liu, Zhenyuan Yang, Haoran Lu, Xilin Gong, Yufang Liu, et al., “Knowledge distillation and dataset distillation of large language models: Emerging trends, challenges, and future directions,” Artificial Intelligence Review, 2025.
- [8]Tim Dettmers, Mike Lewis, Younes Belkada, and Luke Zettlemoyer, “Gpt3.int8(): 8-bit matrix multiplication for transformers at scale,” in Proc. Neural Information Processing Systems (NeurIPS), 2022.
- [9]Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh, “GPTQ: Accurate Quantization for Generative Pre-trained Transformers,” in Proc. Int. Conf. on Learning Representations (ICLR), 2023.arxiv.org/abs/2210.17323
- [10]Zechun Liu, Barlas Oguz, Changsheng Zhao, Ernie Chang, Pierre Stock, Yashar Mehdad, Yangyang Shi, Raghuraman Krishnamoorthi, and Vikas Chandra, “LLM-QAT: Data-free quantization aware training for large language models,” in Proc. Conf. Assoc. Comput. Linguist. Meet. (ACL), 2024.
- [11]Quan Wei, Chung-Yiu Yau, Hoi To Wai, Yang Zhao, Dongyeop Kang, Youngsuk Park, and Mingyi Hong, “RoSTE: An efficient quantization-aware supervised fine-tuning approach for large language models,” in Proc. Int. Conf. on Machine Learning (ICML), 2025.arxiv.org/abs/2502.09003
- [12]Elias Frantar and Dan Alistarh, “Optimal brain compression: A framework for accurate post-training quantization and pruning,” in Proc. Neural Information Processing Systems (NeurIPS), 2022.arxiv.org/abs/2208.11580
- [13]Tim Dettmers, Ruslan A. Svirschevski, Vage Egiazarian, Denis Kuznedelev, Elias Frantar, Saleh Ashkboos, Alexander Borzunov, Torsten Hoefler, and Dan Alistarh, “SpQR: A sparse-quantized representation for near-lossless LLM weight compression,” in Proc. Int. Conf. on Learning Representations (ICLR), 2024.arxiv.org/abs/2306.03078
- [14]Guangxuan Xiao, Ji Lin, Mickael Seznec, Hao Wu, Julien Demouth, and Song Han, “SmoothQuant: Accurate and efficient post-training quantization for large language models,” in Proc. Int. Conf. on Machine Learning (ICML), 2023.arxiv.org/abs/2211.10438
- [15]Ji Lin, Jiaming Tang, Haotian Tang, Shang Yang, Wei-Ming Chen, Wei-Chen Wang, Guangxuan Xiao, Xingyu Dang, Chuang Gan, and Song Han, “AWQ: Activation-aware weight quantization for on-device LLM compression and acceleration,” in Proc. Conf. on Machine Learn. and Syst., 2024.DOI
- [16]Saleh Ashkboos, Amirkeivan Mohtashami, Maximilian L. Croci, Bo Li, Pashmina Cameron, Martin Jaggi, Dan Alistarh, Torsten Hoefler, and James Hensman, “QuaRot: Outlier-free 4-bit inference in rotated llms,” in Proc. Neural Information Processing Systems (NeurIPS), 2024.arxiv.org/abs/2404.00456
- [17]Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer, “QLoRA: Efficient finetuning of quantized llms,” in Proc. Neural Information Processing Systems (NeurIPS), 2023.arxiv.org/abs/2305.14314
- [18]Rajarshi Saha, Naomi Sagan, Varun Srivastava, Andrea Goldsmith, and Mert Pilanci, “CALDERA: Compressing large language models using low rank and low precision decomposi- tion,” in Proc. Neural Information Processing Systems (NeurIPS), 2024.arxiv.org/abs/2405.18886
- [19]Yixiao Li, Yifan Yu, Chen Liang, Nikos Karampatziakis, Pengcheng He, Weizhu Chen, and Tuo Zhao, “LoftQ: LoRA-fine-tuning-aware quantization for large language models,” in Proc. Int. Conf. on Learning Representations (ICLR), 2024.arxiv.org/abs/2310.08659
- [20]Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPoFi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac’h, Haonan Li, Kyle McDonell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou, “The language model evaluation harness,” 2024.
- [21]Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman, “Training Verifiers to Solve Math Word Problems,” arXiv:2110.14168, 2021.arxiv.org/abs/2110.14168
- [22]Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and Charles Sutton, “Program Synthesis with Large Language Models,” arXiv:2108.07732, 2021.arxiv.org/abs/2108.07732
- [23]Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher, “Pointer sentinel mixture models,” in ICLR, 2017.arxiv.org/abs/1609.07843
- [24]Roman Garnett, Bayesian Optimization, Cambridge University Press, 2023.DOI