A Quantum Circuit-Based Compression Perspective for Parameter-Efficient Learning
Authors: Chen-Yu Liu
Chao-Han Huck Yang
Hsi-Sheng Goan
Min-Hsiu Hsieh
Venue: ICLR 2025 Poster (2025)
Keywords: quantum machine learning
quantum computing
parameter-efficient fine-tuning
large language model
variational quantum circuits
Primary area: other topics in machine learning (i.e., none of the above)
TL;DR: A quantum circuit-based approach for parameter generation in parameter-efficient learning is introduced, providing enhanced parameter reduction during training, without requiring a quantum computer for inference.

Abstract: Quantum-centric supercomputing presents a compelling framework for large-scale hybrid quantum-classical tasks. Although quantum machine learning (QML) offers theoretical benefits in various applications, challenges such as large-size data encoding in the input stage and the reliance on quantum resources in the inference stage limit its practicality for tasks like fine-tuning large language models (LLMs). Quantum parameter generation, a novel approach of QML, addresses these limitations by using quantum neural networks (QNNs) to generate classical model weights (parameters) exclusively during training, thereby decoupling inference from quantum hardware. In this work, we introduce Quantum Parameter Adaptation (QPA) in the framework of quantum parameter generation, which integrates QNNs with a classical multi-layer perceptron mapping model to generate parameters for fine-tuning methods. Using Gemma-2 and GPT-2 as case studies, QPA demonstrates significant parameter reduction for parameter-efficient fine-tuning methods, such as Low-Rank Adaptation (LoRA), while maintaining comparable or improved performance in text generation tasks. Specifically, QPA reduces the number of  parameters to $52.06\%$ of the original LoRA for GPT-2 with a slight performance gain of $0.75\%$, and to $16.84\%$ for Gemma-2, with a marginal performance improvement of $0.07\%$. These results highlight QPA’s ability to achieve efficient parameter reduction without sacrificing performance in the quantum parameter generation framework. This work showcases the potential of quantum-enhanced parameter reduction, offering a scalable quantum-classical solution for fine-tuning LLMs while preserving the feasibility of inference on classical hardware.

Published as a conference paper at ICLR 2025
A QUANTUM CIRCUIT-BASED COMPRESSION PER- SPECTIVE FOR CHAAMETER-EFFICEERR LEARNING
Chen-Yu Liu 1.2
Chao-Han Huck Yang? Hsi-Sheng Goan 14.5,6 Min-Hsiu Hsieh
1 Graduate Institute of Applied Physics, National Taiwan University, Taipei, Taiwan
2 Hon Hai (Foxconn) Research Institute, Taipei, Taiwan
3 Georgia Institute of Technology, USA
4 Department of Physics and Center for Theoretical Physics, National Taiwan University, Taipei, Taiwan
5 Center for Quantum Science and Engineering, National Taiwan University, Taipei, Taiwan
6 Physics Division, National Center for Theoretical Sciences, Taipei, Taiwan {d1 02450436,, goan@phys) ntu. huckiyang@gatech edu,
ntu.edu edu. t.w, woxcoon.ooxooo.oooo com
ABSTRACT
Quantum-centric supercomputing presents compelling framework for large- scale hybrid quantum-classical tasks. Although quantum machine learning (QML) offers theoretical benefits in various applications, challenges such as large-size data encoding in the input stage and the reliance on quantum resources in the in- ference stage limit its practicality for tasks like fine-tuning large language models (LLMs). Quantum parameter generation, novel approach of QML, addresses these limitations by using quantum neural networks (QNNs) to generate classi- cal model weights (parameters) exclusively during training, thereby decoupling inference from quantum hardware. this work, we introduce Quantum Parame- ter Adaptation (QPA) in the framework of quantum parameter generation, which integrates QNNs with a classical multi-layer perceptron mapping model to gen- erate parameters for fine-tuning methods. Using Gemma-2 and GPT-2 case studies, QPA demonstrates significant parameter reduction for parameter-efficient fine-tuning methods, such as Low-Rank Adaptation (LoRA), while maintaining comparable or improved performance in text generation tasks. Specifically, QPA reduces the number of parameters to 52.06% of the original LoRA for GPT-2 with slight performance gain of 0.75%, and to 16.84% for Gemma-2, with a marginal performance improvement of 0.07%. These results highlight QPA's abil- ity achieve efficient parameter reduction without sacrificing performance in the quantum parameter generation framework. This work showcases the potential quantum-enhance parameter reduction, offering scalable quantum-classical lution for fine-tune men-tunin LLMs while preserving the feasibility inference on clas- sical hardware.
INTRODUCTION
Decomposing complex problems into components suited for classical or quantum computing allows for more efficient problem-solving. Classical systems well-suited for tasks like data process- ing, while quantum computing shows potential in optimization and exploring large state spaces. Quantum-centre supercomputing (Bravyi et al., 2022; Gambetta, 2022) combines these strengths, offering scalable solutions for challenging problems. This hybrid approach holds promise in quan- tum machine learning (QML), with the potential to support the training and fine-tuning of large models. Conventional QML approaches employ parameterized quantum circuits (PQCs) as quan- tum neural networks (QNNs) (Chen al., 2020), where data is input through specific data encoding methods (Pérez-Salina et al., 2020; Schuld et al., 2021). The updates to QNN parameters during the training process are computed on the classical side, creating a hybrid quantum-classice com- puting framework (Mari al., 2020). When scaled up, quantum-centri supercomputing offers promising paradigm that could reshape the landscape of computational science, particularly in the current Noisy Intermediate-Scake Quantum (NISQ) era (Preskill, 2018). Classical neural networks

---

Published as a conference paper at ICLR 2025
(NNs) can also be combined with QNNs, serving as either pre-proeessing post- post-processing layers (Mari et al., 2020; Liu et al., 2021). While both empirical and theoretical results suggest that QML can offer improvements in specific applications (Cerezo et al., 2022; Huang et al., 2022; Biamonte et al., 2017; Caro et al., 2022; Huang et al., 2021), significant challenges comain-particulle data encoding for large datasets. For instance, gate-angle encoding can result in quantum circuits that are either too deep or require an impractical number of qubits. Another major obstacle to the practicality of QML is the need for a quantum computer during the model inference stage.
in
(a) Quantum Machine learning
Quantum Parameter Generation Process
Fineunte Coddett & Updane Parametern
Evilusaa Cradietia & Updaree Paramatierss
Classical model
Data encoding
Eviluation
Classical Modil
ONN
Mapping Model
Loss Function
V(T)
UC4)
Prediction
U($)
Predicion
Trainable
Tranablle
LLM
conted vector
Inhhaad
MLP
Chunk
[0]
R
Chunk
PEFT Paramelers
[0]
x
Chunk 3
Transformer Blocks
LofA DeRlA Pwils-Taing Assptors....
10)
Churk Rig
ONN
Mapping Model
Text Embedding
with N [log R,a
quants
(c) Quantum Parameter Adaptation (ours)
(d) Parameter-Efficient Fine-Tuning
Figure 1: Overview of (a) Quantum Machine Learning (Mari al., 2020; Mitarai et al., 2018), (b) Quantum Parameter Generation (Liu et al., 2024b), (c) our proposed Quantum Parameter Adaptation (QPA), and (d) Cerumeter-Efficienn Fine-Tuning methods (Houlsby al., 2019).
One such proposal to address both the data encoding challenge and the requirement for quantum hardware during the inference stage is quantum parameter generation (Sidhu & Kok, 2020; Liu et al., 2024b). Instead of using a QNN to interact directly with the data, this approach leverages QNNs to "generate" the weights of target classical NN model during the training process. This quantum parameter generation method: 1) keeps the data input process entirely within the classical model, the trained
2) eliminates the exorbitant need for quantum computing hardware during inference, model is purely classical, and 3) reduces the number of training parameters on a polylogarithmic scale by mapping quantum state basis to the target NN parameters, assuming the QNN is constructed with a polynomial number of layers relative to the qubit count. Further details will be provided in the following sections.
Current studies (Liu et al., 2024c; Lin et al., 2024) of quantum parameter generation have primarily focused on small-scaa models with fewer than one million parameters, where the largest model is up to 0.28M. To more clearly demonstrate the practicality of this quantum approach, the size of the models or problems investigated should be scaled to more realistic levels, extending beyond basic tasks such as handwritten digit classification and simplified reinforcement learning environments.
As model sizes grow, both in quantum and classical machine learning (ML), scaling becomes a key computation challenge. This is especially evident in the rise of large language models (LLMs), which have become foundational in natural language processing tasks. However, training and fine- tuning LLMs such GPT-2 (Radford et al., 2019), GPT-3 (Brown, 2020), and the more recent Gemma-2 (Team et al., 2024) 2resentsssssts its own set of challenges. The immense number of pa- rameters in these models requires vast computational resources, making conventional fine-tuning
2

---

Published as a conference paper at ICLR 2025
approaches computationally expensive and impractical for many use cases. To address these is- sues, pudes..armeterr parameter- -effnnettreffiiinntt fine-tuning methods (PEFT) like Low-Rank Adaptation (LoRA) (Hu et al., 2021), DecomppDed Low-Rank Adaptation (DoRA) (Liu et al., 2024d), Prefix-Tuning Tuning (PT) (Li & Liang, 2021; Yang et al., 2021b), and adapters have been proposed (Houlsby et al., 2019; Lin al., 2020). These methods aim reduce the number of trainable parameters while maintaining model performance, yet the challenge of balancing efficiency and effectiveness remains critical area of research.
We draw inspiration from both quantum parameter generation and PEFT methods for LLMs, which demonstrate that PQCs can serve as parameter generators for machine learning models, and changes to LLM weights can be captured by low-rank or smaller-sized representations (models). We sug- gest that the training parameters in PEFT methods can generated using a combination of QNNs and classical multi-layer perceptron (MLP) mapping model, further reducing the parameter count. This leads to our introduction of the Quantum Parameter Adaptation (QPA) method. QPA enables additional parameter reduction during fine-tuning by leveraging the quantum parameter generation method to generate PEFT parameters, as shown in Fig. 1. The figure also provides an overview of QML, quantum parameter generation, and PEFT for comparison, clearly illustrating how QPA gen- erates the PEFT parameters. In experiments with Gemma-2 (Team et al., 2024) and GPT-2 (Radford al., 2019), we demonstrate that QPA reduces the number of parameters in methods such LoRA, DoRA, PT, and Feed-Forward Adapters (FFAs) by nearly an order of magnitude (e.g.. 10 - 10%), while achieving better or comparable perplexity in text generation tasks. QPA marks the first exam- ple of quantum computing applied to fine-tuning classical LLMs at a practical scale, while enabling inference be performed entirely on classical hardware. Further theoretical analysis of QPA's con- vergence behavior, as well as its trainability and learnability properties, is left for future work.
The main contributions of QPA include:
Efficient adaptation through quantum parameter generation: QPA utilizes quantum parameters from the PQC, which scale in proportion to the number of qubits N, to generate parameters that scale with the Hilbert space size 2N,. When applied to tunable parameters in PEFT tasks, this property enables highly efficient adaptation by generating parameters through quantum methods.
By incorporating quantum parameter generation, our approach to combining QML with LLMs is more practical compared to conventional QML methods (i.e., Quantum Transformer (Di Sipio et al., 2022)). The data-encoding issues associated with conventional QML (Yang et al., 2021a) have been eliminated, and the inference stage no longer requires quantum hardware. This is particularly important for tasks that demand short response times, reliance remote quantum computers could introduce delays due to queuing and increased costs.
Practical application QML in LLMs:
Scaling up the size of existing quantum parameter generation studies: In this study, we scale up the application of quantum parameter generation by fine-tuning up to the linear layer of the Gemma-2 (2B) model, where the target layer consists of 0.52B parameters. This approximately 1785 times larger than the largest previously studied model (0.28M), significantly pushing the boundaries of how QML can be applied.
Flexibility, applicability, and efficiency in classical fine-tuning methods: We demon- strate that quantum parameter generation is not only capable of generating classical NN parameters, but is also applicable to a wide-range of popular parameter-tuning tasks. These tasks include tuning parameters in methods such as LoRA, DoRA, PT, and FFA, all while achieving comparable or better perplexity in text generation tasks with reduced parameter requirements.
2 RELATED WORKS
Parameter-Efficiet Fine-Tuning (PEFT) Methods. To address the challenge of fine-tuning LLMs, PEFT methods aim to reduce the number trainable parameters while maintaining or even improving model performance. Key PEFT approaches include LoRA (Hu et al., 2021) and DoRA (Liu et al., 2024d), which assume that the changes in model weights during fine-tuning lie a low-rank subspace. Instead of updating the full weight matrices, these methods add small, train-
3

---

Published as a conference paper at ICLR 2025
able low-rank decomposition matrices to the model's weights, effectively reducing the number of trainable parameters while capturing the essential adjustments. Another approach involves adapters, which are small feed-forward layers inserted between existing layers of the neural network (Houlsby et al., 2019; Lin et al., 2020). Only these adapter layers are fine-tuned, leaving the rest of the model unchanged, thus significantly reducing the training overhead. PT (Li & Liang, 2021; Yang al,, 2021b) takes different approach by introducing tunable prefix vectors that are prepended to the in- put hidden states at each layer. During fine-tuning, only these prefix vectors are updated, while the core model parameters remain frozen. These techniques optimize fine-tuning efficiency by focusing on smaller, spec-fee modifications.
From Quantum Circuit Learning to Large-Scale Representation Modeling. QML leverages quantum properties such as superposition and entanglement, presenting theoretically promising approach to accelerate the training and learning process (Du et al., 2021a; Schuld & Killoran, 2019; Farhi & Neven, 2018). However, the process of encoding classical data into quantum states increases the depth of quantum circuits, further adding to the depth of QNNs (Pérez-Saling) Schuld et al., 2021). We refer to QML approaches that directly interact with data as "conventional QML," distinct from the quantum parameter generation approach discussed later. There have been proposals suggesting that the GPT model could be integrated into the quantum computing paradigm (Liao & Ferrie, 2024), where the transformer architecture implemented using quantum circuits (Gao et al., 2023; Khatri et al., 2024). In such case, the input data is encoded into quantum states through amplitude encoding methods. Consequently, these QML methods require access to quantum computers during the inference stage.
al., 2020;
Training Classical Neural Networks via Quantum Computing, Leveraging quantum computing to train classical NNs offers a promising approach where the resulting model remains entirely clas- sical, effectively addressing the challenges of data encoding and the reliance on quantum hardware during inference. One example involves utilizing quantum walks as search process to optimize the parameters of classical NNs (de Souza et al., 2021). Another method proposes employing a quantum hypernetwork to train classical binary NN (Carrasquilla et al., 2023). However, the practical utility of this approach is constrained by its ability to train only binary NNs, limiting its applicability in more general settings.
QUANTUM PARAMETER GENERATION BASED EFFICIENT ADAPTATION
In LoRA and DoRA, one primary assumption is that weight updates can be represented by low-rank matrices. However, these methods often lack flexibility in exploring parameter settings between integer ranks and r + leaving the intermediate values unexamined. A method capable of investi- gating the parameter space between and + 1 could potentially enhance performance by enabling more precise, "fine-graid grained" adjustments. This limitation also applies to other PEFT methods with rigid configurations, such PT, where the number of trainable parameters is strongly tied to the input size.
Inspired by this idea and combined with quantum circuit based compression, which uses PQC and mapping model to train the target NN with fewer parameters, we hypothesize that using PQC-based QNN and mapping model a parameter generator can take advantage of the fact that only a small number of QNN parameters are required to control the measurement probabilities, governed by the dimension of the Hilbert space. In other words, we propose that the high-dimensional Hilbert space facilitates an efficient representation for adaptation. This could lead to more detailed and precise exploration of the representation space in PEFT methods.
3.1 QUANTUM CIRCUIT BASED MODEL PARAMETER GENERATION.
We consider a parameter generation process that provides a different approach from conventional QML. Consider target NN model with parameters = (ai, a2,..., .,, am), where is the number of parameters. A PQC with N = flog, ml qubits and L layers is constructed using a circuit ansatz, represented as:
N-1
N
R2 (0) )
(e)) =
CNOT #+1
II 1=1
10
(1)
1=1
4

---

Published as a conference paper at ICLR 2025
where the single-qubit rotation gate R2y is associated with the tunable parameter 0/0) with qubit index j and layer index L, and CNOT represents the two-qubit controlled-OOT gate. With a Hilbert space of size 2 where 2 > m, this PQC produces 2 distinct measurement probabilities, ((: (b)) E [0, 1] for i E
}. J. The parameter size of 0 depends on N and L. where L a hyperparameter similar to those in classical MI.. Typically, I. scales proportionally to the num- ber of qubits, either ((N) or in some cases O(N2) (Cerezo et al., 2021; Sim et al., 2019; Benedetti al.. 2019), though it can be generalized to looser polynomial scale, O(poly(N)). Thus, with polynomial layers the PQC, we can generate 2| m 2 m parameters (probabilities) using Oppolylog(m) ()) PQC parameters.
At this stage, the measurement probabilities are values between 0 and 1. To map these probabilities to the target parameters E IRm we employ MLP mapping model G with tunable parameters The input to G is the binary representation of the basis (of length N) and the corresponding measurement probability, such that
Go Gb((o)), (())))
E
Here, only the first m basis states are used to cover all parameters in the target NN. Since the input size of G6 is N + 1, the size of b can also be controlled a scale of Oppolylog(M)). Consequently, is generated from the output of the PQC and the mapping model G,- By tuning 0 and b, we effectively influence the value of the loss function L. which is evaluated by the target NN for a given task.
Gradient Estimation of Quantum Circuit Compressed Parameters. The target NN parameters are generated through the use of PQC coupled with mapping model. The quantun-dependent parameters, represented as (0, b), impact the target NN parameters via the quantum state prepara- tion and measurement steps. The gradient of the loss function, reflecting the influence of quantum parameters, is expressed as:
da ).a..
) VaL.
Vo
a(0,b) b)
So denotes the Jacobian matrix, which describes how sensitive the classical In this expression, गe parameters
changes in the quantum parameters (0, b). This provides high-level overview of the gradient in an exact quantum state simulation. In practical applications involving real quantum computers, the gradient calculation must account for the parameter shift rule and its variants (Mitarai et al., 2018; Schuld et al., 2019).
Parameter Update of Quantum Circuit Compressed Parameters. The learning rate n is critical factor, particularly due to the complex dynamics introduced by the quantum-classical interface. The update for the quantum parameters is defined as:
0 o. VobC.
This rule ensures that the quantum parameters are updated to optimize the performance of the target NN.
Using the gradient computation and parameter update rule, the parameter generation process of QPA has been applied to image classification with convolutional neural networks (CNNs) (Liu et al., 2024b;a; Liu & Chen, 2024), flood prediction (time series) with long short-term memory (LSTM) models (Lin et al., 2024), and policy gradient reinforcement learning in CartPole and MiniGrid environments (Liu et al., 2024c). These applications demonstrated reduction in training parameters while maintaining similar performance.
Table 1: Configuration of the mapping model Go, with N representing the number of qubits for each task.
Hyperparameter
Meaning
Value
Input size
Input of the mapping model (lox), (0)))
N +++1
Hidden dimension
Main structure of the MLP mapping model
[32, 64, 128, 128, 64, 32, mmmpp]
5

---

Published as a conference paper at ICLR 2025
3.2 BATCHED PARAMETER GENERATION OF QUANTUM PARAMETER ADAPTATION (QPA)
If the target NN model consists of m parameters, the required number of qubits is N = floge m ]- For instance, scaling this up to m 10 (one billion) parameters would require N 30 qubits. Although quantum system with 30 qubits is feasible on today's ' hardware and in classical simu- lations, the GPU memory requirements (around 16 GB) and evaluation time (several seconds per circuit) (Google, 2024) make it impractical for MI tasks that demand extensive repetitions within reasonable time frame.
In our approach, the parameters (following the above syntax) of the target NN model are split into flah chunks, with each chunk containing Nmlp parameters, such that nich = [[m/nmippl other words, the qubit count be reduced by generating more than parameter of the target NN per quantum basis.
The mapping model, now represented as Go. takes as input (ot) and K (O))), and outputs a batch of Mmdp parameters a for each chunk:
(ā1, 02 aner):
(5)
Gb ( (de 0)) () äi,
Vi E (1,2, ncch),
0 = (0i,1, 0,.2, Os.j); Vj E (1,2,..., (mmpp)-
(7)
This is achieved by using decoder-like like structure in the MLP within the mapping model G2, where the output size is expanded from 1 to Benips the detailed configuration is shown in Table. 1. As result, the number of qubits required reduced from N flog2 m]
N = [log2 noh = [log2
(r
m
1mmpp
This adjustment effectively reduces the qubit requirement by approximately [log2 1mmp qubits com- pared to the original quantum parameter generation. The original method can be viewed as a special case where nmlp 1. Although this reduction in qubit count increases the number of parameters in the mapping model (due to the expanded output size), it offers a significant memory reduction, as the memory needed to store the quantum state decreases by factor of 1/mmmpp-
For example, with
10 and Rmip 1024, the qubit usage be reduced to N 10 1)1 20. This 33% of qubit saving reduces the memory required to store the quantum 1024
[log2
state to just 1/ 1/1024 of what is needed for 30 qubits, and speedup the classical simulation as well.
3.3 FROM MODEL TUNING GENERAL PARAMETER-TUNING TASK
In QPA, we consider the tuning target of quantum parameter generation from the full model param- eters of a target NN to the parameters of PEFT method, enabling significantly larger tasks to be handled. Additionally, with the help of batch parameter generation, the scale of the target task is further amplified. Following the previous notation, the parameter a now represents the parameters of a PEFT method.
Taking LoRA as an example, for a pre-trained weight matrix W,, Rdxk the low-rank decomposi- tion of the update is Wo AW Wo + BA, with B Rdxr A E Re*t and < min(d, k). In this case, QPA generates these two low tow-rank matrices using Eq. 6 and Eq. 7, where a represents the elements of A and B, and the required qubit count is:
(rrd (
N [log2
(LoRA case).
The tuning of QPA can then follow the gradient evaluation and update rules in Eq. and Eq. A similar situation applies to DoRA, where there are additional ht parameters in the magnitude vector to be tuned. In this case, the required qubit count is:
(1r1d + +))++)+++ + k1)1
N = [loga
(DoRA case).
(10)
Rmily

---

Published as a conference paper at ICLR 2025
These examples can be generalized to other karameter-tuning tasks. The schematic of QPA is shown in Fig. I. where the PEFT method is applied to only one layer in the LLM, as we will discuss in Sec. 4, which describes the experiment. For scenarios where gradient-based tuning is not supported, other non-gradient-bere based optimizers (e.g. Nelder-Mead and COBYLA) may be required for the parameter update process.
EMPIRICAL EXPERIMENTS
Our objective is to assess the effectiveness of QPA, as outlined in Sec. 3, to determine whether the proposed QPA can effectively reduce the number of parameters while maintaining or surpassing the performance of existing PEFT methods. This evaluation is based on one hypothesis that the high-dimensional Hilbert space enables efficient representation for adaptation. The experiment is conducted using quantum circuit simulation via PyTorch and TorchQuantum (Wang et al., 2022). At this stage, noise effects on the quantum system are ignored, and the quantum state amplitudes (prob- abilitics) are obtained exactly. A discussion on the impact of finite measurement shots and noise is provided in Appendix G. We assess the text generation perplexity of Gemma-2 (2B) and GPT-2 (80M), fine-tuned on the WikiTeext2 dataset, using several well-known PEFT methods, including LoRA, DoRA, PT, and Feed-Forward Adapter (FFA). Gemma-2 was selected as one of the most recent LLMs', offering competitive performance relative to models such as Phi-2-2B (Javaheripi al., 2023), LLaMA2-7B (Touvron et al., 2023), and Mistral-7B (Jiang al., 2023). Additionally, we assess GPT-2 XL (1.5B) with QPA, with further discussion provided in Appendix A.1. For com- parison, we apply QPA to generate the parameters for these PEFT methods following the procedure outlined in Sec. 3.3. The full hyperparameter configurations are provided in Appendix C. while additional results on a different dataset are presented in Appendix E. To isolate the effects of QPA, we simplify the PEFT setup by freezing all layers of Gemma-2 and GPT-2, and fine-tuning only the final linear layer, commonly referred to as the "Imhead." This layer comprises 38. 59M parameters in GPT-2 and 0.52B parameters in Gemma-2. The QNN repetition L is fixed at 8 for all cases, except those discussed in the "Effect of Deeper QNN" paragraph.
4.1 PERFORMANCE OF QPA
Low-rank adaptation methods with QPA. First, using LoRA and DoRA as baselines, QPA is applied to generate the low-rank matrices for these methods, with an additional magnitude vector generated for DoRA. In this experiment, the rank of the low-rank matrices to be gen- erated is fixed at 4 (other results could be found at Appendix D), and various chunk sizes Umdp are investigated to adjust the number of trainable parameters. Specifically, Ammp E (256, 512, 1024, 2048, 4096, 8192) for GPT-2 with LoRA, Rmip {512, 1024, 2048, 4096, 8192} for GPT-2 with DoRA, Tmmp E {1024, 4096, 8192, 16258, 32768, 65536) for Gemma-2 with LoRA, and Rempp E (512, 1024, 2048, 4096, 8192). For comparison, the results for LoRA and DoRA are obtained by varying the rank r E {1, 2, 4, 8, 12.3
In the results, as illustrated in Fig. 2, QPA consistently outperforms LoRA and DoRA across various parameter configurations. For GPT-2, QPA achieves lower testing perplexity compared to LoRA, particularly in configurations with fewer trainable parameters, demonstrating its efficiency. Even with larger parameter counts, QPA maintains comparable or better performance than LoRA. The best result in terms of parameter reduction and improved perplexity is achieved with 106264 train- able parameters and a perplexity of 1.583 for QPA, while LoRA requires 204100 trainable param- eters and achieves a perplexity of 1.595. This indicates that QPA reduces the trainable parameters to 52.06% while delivering a O. 0.75% improvement in performance. Similarly, for Gemma-2, QPA demonstrates significant improvements over LoRA in the lower parameter regime, with the gap nar- rowing as the parameter count increases, yet QPA consistently maintains better perplexity overall. The best result here is 173, 888 trainable parameters with a perplexity of 1.417 for QPA, compared to 1, 032,, 192 trainable parameters with a perplexity of 1.418 for LoRA. This corresponds to reduc- tion to 16.84% in trainable parameters with a 0.07% performance improvement. When comparing QPA to DoRA, the results initially show QPA having higher perplexity with fewer parameters for both GPT-2 and Gemma-2. However, as the number of trainable parameters increases, QPA sur-
We selected the deployed Gemma-2 version released on August 8th, 2024: https: http//hhggggaccc...e// co/goog1 e/ /ggmmm-- 2b2b.
7

---

Published as a conference paper at ICLR 2025
GPT-2
Gemma-2
GPT-2
Gemma-2
1.62
- LoRA QPA
1.44
LoRA QPA
DoRA
DoRA
Testing perplexity
QP1
QP
1.60
6.5
6.0
1.41
5.5
1.56
1.40
5.0
10a
10
10"
107
10
10a
107
10a
10"
Trainable Parameters
Trainable
Trainable
Figure 2:
Testing perplexity GPT-2 and Gemma-2 models compared to the number of trainable parameters for LoRA, DoRA, and QPA the WikiText-2 dataset.
Table 2:
Training parameters and testing perplexity for GPT-2 and Gemma-2 using PEFT and QPA methods, with emphasis on configurations achieving the most significant parameter reduc- tions. Complete results are provided in Fig. 2 and Fig. 3.
PEFT Method
GPT-2 Params (%)
Gemma-2 # Params (%)
PPL
PPL
LoRA
0.52
1.595
0.19
1,418
QPA LoRA (Ours)
0.27
1.583
0.03
1.417
DoRA
4.36
5.003
0.09
5.504
QPA DoRA (Ours)
0.27
4.955
0.05
5,487
1.01
2.225
0.20
1,530
QPA PT (Ours)
0.18
2.327
0.01
1.540
FFA
0.76
1.763
0.40
1,439
QPA FFA (Ours)
0.18
1.689
0.01
1.507
passes DoRA, ultimately achieving comparable better results. The result with best parameter reduction are concluded in Table. 4.1, with the parameter ratio calculated relative to the number of parameters the target layer. the case Gemma-2, the performance gap between QPA and DoRA also narrows the number of trainable parameters increases, with QPA remaining compet- itive across all scales. While the magnitude of these performance improvements may appear small, the key takeaway is that QPA significantly reduce the number of trainable parameters in PEFT methods without incurring significant loss performance.
QPA Prefix-Tuning and Feed-forward adapter. In the context of PT, QPA is applied to the tunable prefix vector that is prepended to the input of the target linear layer, where the length of this vector is traditionally fixed match the input size of the layer. QPA offers more flexible approach by allowing different parameter configurations, enabling exploration beyond the conventional constraints of input length. The QPA setup uses various chunk sizes Nmdp (256, 512, 1024, 2048, 4096, 8192] for GPT-2 and 7mpp E {1024, 2048, 4096, 8192, 16258, 32768} for Gemma-2, with an additional Nmlpp 65536 for QPA-FFA case.
As shown in Fig. 3 and Table. 4.1, for GPT-2, QPA does not outperform PT at lower parameter counts but shows potential for extending the parameter space and achieving better results as the number of parameters increases. In the scenario with the most parameter reduction, QPA achieves 72, 552 trainable parameters and perplexity of 2.327, compared PT with 393, 216 trainable parameters and perplexity of 2.225. This indicates that QPA reduces the number of parameters to 18.45%, at the cost of a 4.38% performance loss.
For Gemma-2, QPA initially performs par with PT but surpasses it as the number of trainable parameters increases, leading to superior performance at higher parameter scales. This flexibility in parameter tuning afforded by QPA allows for a broader exploration of the parameter space, poten- tially resulting in better outcomes than traditional PT. By inserting small feed-forward layers before the target linear layer, QPA generates the parameters for the FRA. For GPT-2, QPA initially outper-
8

---

Published as a conference paper at ICLR 2025
GPT-2
Gemma-2
GPT-2
Gemma-2
1.34
FFA
1.50
FFA
Testing pergiciity
OPA
2.25
1.52
1.9
2.20
1.8
A
1.46
2.15
PT
1.50
PT
1.7
QPA
OPA
1.44
10a
10"
10a
10
10a
10"
10a
10
# Trainable Parameters
Trainable Parameters
# Trainable Parameters
0 Trainable Parameters
Figure 3: Testing perplexity of GPT-2 and Gemma-2 models compared to the number of trainable parameters for prefix-tuning (PT), feed-forward adapter (FFA), and QPA on the WikiText-2 dataset.
forms FFA at lower parameter counts, but as the number of parameters increases, QPA's performance deteriorates compared to FFA. In contrast, for Gemma-2, QPA does not outperform the classical FFA approach across the entire parameter range. However, it still demonstrates competitive performance, maintaining comparable testing perplexity even with larger parameter counts. Although QPA does not consistently outperform PT and FFA in terms of testing perplexity, the significant reduction in trainable parameters (0.20% - 0.01% % for PT and 0.40% - 0.01% for FFA on Gemma-2, as shown in Table 4.1) with only slight performance loss remains notable and promising result.
4.2
EFFECTS OF QPA SETTINGS
(a)
(b)
(c)
(d)
1.805
10 -13
DPA LaTA Cemmae2
OnA DotA CemTIA
OP12
persioatty
1.
2,0
OSA G772
Optinal
UAk Genimai2
1.595
1.600
L-RA- GPRA2
LOAA GPP
1.46
CPA Loft Gamma-2
LoRA Gemma-2
1.7
1.590
1.585
1.500
1.575
1.40
Parameters
reputition
Figure 4: (a) Qubit usage versus the number of trainable parameters for QPA applied to LoRA and DoRA on GPT-2 and Gemma-2 models. (b) The relationship between testing perplexity and LoRA rank for QPA applied GPT-2 and Gemma-2. (c) and (d) Testing perplexity depending on the QNN repetition L for QPA applied to LoRA on GPT-2 and Gemma-2.
Trade-off of qubits counts and parameter size. As described in Sec. 3.2, the qubit usage in QPA follows Eq. 8. Increasing the chunk size Rmlp for batched parameter generation increases the total number of trainable parameters in QPA, as Nemip also determines the output size of the MLP mapping model. Consequently, per Eq. 8, the required qubit count decreases. Fig. 4 (a) illustrates the qubit usage corresponding to the QPA results shown in Fig. 2. The actual qubit usage ranges between and 11 qubits, which are reasonable values for both classical simulations and fault tolerant quantum computers in the foresecable future While QPA settings with more qubits tend to reduce the number trainable parameters PEFT. this often results in higher perplexities. To achieve optimal performance, Remip should be carefully tuned to balance the number of trainable parameters and the resulting perplexity.
Optimal LoRA rank. As observed in previous LoRA and DoRA studies, increasing the rank of the low-rank matrices does not necessarily lead better results. In fact, there exists an optimal rank for
2 IBBM Quantum announced the achievement of discovering the quantum error correcting code with the prop- erty of preserving up to 12 logical qubits using 288 physical qubits through emor correction methods (Bravyi al. 2024): https: /www. i bm. com/ quantumt /bl og /wtp/natureeeee dpo- error-correnr

---

Published as a conference paper at ICLR 2025
the best performance. A similar behavior can be seen when applying QPA to low-rank adaptation methods. As shown in Fig. 4 (b), the optimal LoRA ranks (indicated by stars) highlight that QPA achieves its best performance at LoRA rank of for GPT-2 and 4 for Gemma-2, with Gemma-2 consistently maintaining lower perplexity than GPT-2 across all ranks. The chunk size is fixed at Amdp 2048 for GPT-2 and 7nddy 8192 for Gemma-2. As the LoRA rank increases, testing perplexity for GPT-2 rises significantly, while for Gemma-2, it remains relatively stable.
Effect of Deeper QNN. In this study, the QNN (quantum circuit) ansatz is shown in Eq. con- structed by Ry and CNOT gates. The performance comparison of different circuit ansatz is pre- sented in Appendix F. The expressiveness of the QNN strongly depends on the number of repeti- tions L of the corresponding ansatz. A larger number of L results in a deeper QNN, which enhances expressiveness.
Fig. (c) and (d), the testing perplexity results for different QNN repetitions I. in QPA applied to LoRA on GPT-2 and Gemma-2 are shown. The orange lines represent the baseline LoRA testing perplexity without QPA, where LoRA rank = 4 for GPT-2 and rank = 2 for Gemma-2. Fig. 4 (c) shows that for GPT-2, QPA LoRA achieves lower perplexity, which slightly decreases as L increases, with the LoRA rank fixed at and Rmppp = 2048. Similarly, in Fig. 4 (d), for Gemma-2 (LoRA rank- 2 and mlppp 8192), QPA LoRA initially performs comparably to standard LoRA but begins to outperform LoRA when L exceeds 64, with more significant reductions in perplexity observed at higher values of L..
In general, when using a universal gate set, such as one containing Rx. Ry, Rz, phase shift P(e), and CNOT gates, the Solovay- Kitaev theorem (Dawson & Nielsen, 2005) guarantees that QNN can approximate any unitary transformation to arbitrary precision. Thus, with sufficient depth (i.e., larger L). a QNN constructed from such gate set can approximate any quantum state, including those that optimally map to the PEFT parameters. As the depth of the QNN increases, it gains the expressivity required to model more complex transformations (Du et al., 2020; Childs, 2017), allowing it to approximate optimal parameter configurations for fine-tuning. This is evident in the reduction of testing perplexity as I. grows, illustrating the advantages of deeper QNNs in capturing richer quantum representations. Notably, in practice, good performance can still be attained with more restricted gate set and practical layer depths. In our study, we employ Ry and CNOT gates with L = 8 in the main experiments, and extend up to L = 2( in this section, demonstrating the scalability of the approach. Notably, an investigation into the gradient variance of quantum circuit parameters is presented in Appendix H. Our findings indicate that the gradient variance does not exhibit the exponential vanishing behavior (commonly referred to as the barren plateau) as qubit usage increases. However, a slight downward trend is observed with increasing L.
CONCLUSION
In conclusion, this work introduces Quantum Parameter Adaptation (QPA) as a new approach for enhancing PEFT methods by leveraging QNNs to generate trainable parameters for LLMs. QPA ad- dresses the critical challenge of reducing the number of parameters required for fine- tuning. which is particularly important for large-scale models. By incorporating QPA into established PEFT methods, such as LORA, DoRA, PT, and FFA, we demonstrate that QPA significantly reduces the trainable parameters (i.e., from 0.40% to 0.01%) while maintaining comparable or even improving model performance in text generation tasks. Moreover, the decoupling of near-term available quantum re- sources (i.e., 4 to 11 qubits) from the inference phase ensures that the quantum benefits are leveraged during training without adding deployment complexities. These results underscore the scalability and efficiency of QPA in fine-tuning LLMs, making it a promising solution for mnantum-classinn hybrid computational frameworks.
Looking ahead, future research will focus on a more comprehensive theoretical investigation of QPA, particularly in terms of convergence behavior, trainability, and learnability. Expanding QPA's application across a broader range of neural network architectures and tasks beyond text generation will be critical for validating its generalizability and robustness. Furthermore, while we have an- alyzed QPA using a real quantum computer noise model in Appendix G, conducting experiments on actual quantum hardware will be crucial step toward developing practical quantum-classen hybrid solutions. These efforts will contribute to establishing QPA as a foundational approach for fine-tuning I.LMs in the emerging landscape of quantum-centric supercomputing.
10

---

Published as a conference paper at ICLR 2025
ACKNOWLEDGMENTS
H.-S. Goan acknowledges support from the National Science and Technology Council, Taiwan, un- der Grants No. NSTC 113-2112-N-0000222-233 No. NSTC 113-2119-M-002-021, No. NSTC from the US Air Force Office of Scientific Research under Award Number FA2386-23-1- 1--022 and from the National Taiwan University under Grants No. NTU- CC114L895004 and No. NTU-CC-1 13.891604. H.-S. Goan is also grateful for the support of the "Center for Advanced Computing and Imaging in Biomedicine (NTU-1 14L_907702" through the Featured Areas Research Center Program within the framework
10119-M-002-017-M0
the Higher Education Sprout Project by the Ministry of Education (MOE), Taiwan, the support of Taiwan Semiconductor Re- search Institute (TSRI) through the Joint Developed Project (JDP) and the support from the Physics Division, National Center for Theoretical Sciences, Taiwan.

---

Published as a conference paper at ICLR 2025
REFERENCES
Shahnawaz Ahmed, Carlos Sánchez Muñoz, Franco Nori, and Anton Frisk Kockum. Quantum state tomography with conditional generative adversarial networks. Phys. Rev. Lett., 127:140502, Sep 2021. doi: 10. 10.1003/hysReeeeett.... 140502. URL https: wiik..napps..............e...... org/do//11...
11C3/PhysReviett. 127. 140502.
Marcello Benedetti, Erika Lloyd, Stefan Sack, and Mattia Fiorentini. Parameterized quantum cir- cuits machine learning models. Quantum Science and Technology, 4(4)004301 2019.
Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd. Quantum machine learning, Nature, 549(7671):195-225) 2017.
Sergey Bravyi, Oliver Dial, Jay M Gambetta, Darío Gil, and Zaira Nazario. The future of quantum computing with superconducting qubits. Journal of Applied Physics, 132(16), 2022.
Sergey Bravyi, Andrew W Cross, Jay M Gambetta, Dmitri Maslov, Patrick Rall, and Theodore Yoder. High-threshold and low-overhead fault-tolerant quantum memory. Nature, 627(8005): 778-782, 2024.
Tom B Brown. Language models are few-shot learners. arXiv preprint arXiv: 14165, 2020.
Matthias C Caro, Hsin-Yuan Huang, Marco Cerezo, Kunal Sharma, Andrew Sombooreer, Lukasz Cincio, and Patrick Coles. Generalization quantum machine learning from few training data. Nature communications, 13(1):4919, 2022.
Juan Carrasquilla, Mohamed Hibat-Allah, Estelle Inack, Alireza Makhzami, Kirill Neklyudov, Gra- ham W Taylor, and Giacomo Torlai. Quantum hypernetworks: Training binary neural networks in quantum superposition. arXiv preprint arXiv:2301.08229, 2023.
Marco Cerezo, Andrew Arrasmith, Ryan Babbush, Simon Benjamin, Suguru Endo, Keisuke Fu- jii, Jarrod McClean, Kosuke Mitarai, Xiao Yuan, Lukasz Cincio, al. Variational quantum algorithms. Nature Reviews Physics, -4444444 2021.
Marco Cerezo, Guillaume Verdon, Hsin- Yuan Huang, Lukasz Cincio, and Patrick Coles. Chal- lenges and opportunities quantum machine learning. Nature Computational Science, 2(9): 567-576, 2022.
Samuel Yen-Chi Chen, Chao-Han Huck Yang, Jun Qi, Pin- Yu Chen, Xiaoli Ma, and Hsi-Sheng Goan. Variational quantum circuits for deep reinforcement learning. IEEE access, 8:141007- 141024, 2020.
Andrew M Childs. Lecture notes on quantum algorithms. Lecture notes at University of Maryland, 5, 2017.
Christopher M Dawson and Michael A Nielsen. The solovay-kitaev algorithm. arXiv preprint quant-ph/0505000, 2005.
Luciano S de Souza, Jonathan HA de Carvalho, and Tiago AE Ferreira. Classical artificial neural network training using quantum walks search procedure. IEEE Transactions on Computers, 71(2):378-388 2021.
Tim Dettmers, Mike Lewis, Younes Belkada, and Luke Zettlemoyer. Gpt3. int8 (): 8-bit matrix multiplication for transformers at scale. Advances in Neural Information Processing Systems, 35: 30318 30332, 2022.
Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. Qlora: Efficient finetuning of quantized 1ms. Advances in Neural Information Processing Systems, 36, 2024.
Riccardo Di Sipio, Jia-Hong Huang, Samuel Yen-Chi Chen, Stefano Mangini, and Marcel Worring. The dawn of quantum natural language processing. In Proc. ICASSP, pp. 8612-8616. IEFE, 2022.
Laia Domingo, Carlo, and Borondo. Taking advantage of noise in quantum reservoir computing. Scientific Reports, 13(1):8790, 2023.
12

---

Published as a conference paper at ICLR 2025
Yuxuan Du, Min-Hsiu Hsich, Tongliang Liu, and Dacheng Tao. Expressive power of parametrized quantum circuits. Physical Review Research, 2(3):033125, 2020.
Yuxuan Du, Min-Hsiu Hsieh, Tongliang Liu, and Dacheng Tao. A grover-search based quantum learning scheme for classification. New Journal of Physics, 23(2):23000,, 2021a.
Yuxuan Du, Min-Hsiu Hsieh, Tongliang Liu, Shan You, and Dacheng Tao. Learnability of quantum neural networks. PRX quantum, 2(4):040337, 2021b.
Edward Farhi and Hartmut Neven. Classification with quantum neural networks term pro- cessors. arXiv preprint arXiv: /802.00002 2018.
Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh, Gptq: Accurate post-training quantization for generative pre-trained transformers. arXiv preprint arXiv:2210.1732. 2022.
Jay Gambetta. Quantum-centric supercomputing: The next wave of computing. IBM Research Blog. 2022.
Yeqi Gao, Zhao Song. Xin Yang. and Ruizhe Zhang. Fast quantum algorithm for attention compu- tation. arXiv preprint 13XXv:2307008045 2023.
Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249-256. JMLR Workshop and Conference Proceedings, 2010.
Quantum AI Google. Choosing hardware for your qsim simulation. https:/ quantuuai.. google/ httggg/l//smmm/ee//e/e/eee///ase cwwcch 2024.
Jeongwan Haah, Aram W. Harrow, Zhengfeng Ji, Xiaodi Wu, and Nengkun Yu. Sample-optimal tomography quantum states. IEEE Transactions on Information Theory, pp. 1-1, 2017. ISSN 1557-9654. doi: 10.1109//i.2111227199444 URL http: dx /ttp/xxwxiiooo//ooooo//o./o.ddod 10. htt.:/.................. 100./1199TTT 2117.2219044
Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, An- drea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efficient transfer learning for nlp. In International conference on machine learning, pp. 2790-2799, PMLR, 2019.
Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprini arXiv:2106.09685, 2021.
Hsin-Yual Huang, Michael Broughton, Masoud Mohseni, Ryan Babbush, Sergio Boixo, Hartmut Neven, and Jarrod R McClean. Power of data quantum machine learning. Nature communica- tions, 12(1):2631 2021.
Hsin Yuan Huang, Michael Broughton, Jordan Cotler, Sitan Chen, Jerry Li, Masoud Mohseni, Hart- mut Neven, Ryan Babbush, Richard Kueng, John Preskill, et al. Quantum advantage in learning from experiments. Science, 376(6598): 182-1186. 2022.
Mojan Javaheripi. Sébastien Bubeck, Marah Abdin, Jyoti Aneja, Sebastien Bubeck, Caio César Teodoro Mendes, Weizhu Chen, Allie Del Giorno, Ronen Eldan, Sivakanth Gopi, et al. Phi-2: The surprising power of small language models. Microsoft Research Blog, 2023.
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 preprint arXiv:2310.068255 2023.
Nikhil Khatri, Gabriel Matos, Luuk Coopmans, and Stephen Clark. Quixer: A quantum transformer model. arXiv preprint arXiv:2406. 20l.:240000000555, 2024.
Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint w:Xiv22101.00190 2021.
Yidong Liao and Chris Ferrie. Gpt on a quantum computer. arXiv preprint 4rXiv:2403.09418 2024.
13

---

Published as a conference paper at ICLR 2025
Chu-Hsuan Abraham Lin, Chen- Yu Liu, and Kuan- Chen. memory: Application on flood prediction problem. arXiv preprint arXiv:2407.08617, 2024.
Quantum-train long short-term
Zhaojiang Lin, Andrea Madotto, and Pascale Fung. Exploring versatile generative language model via parameter-efficien transfer learning. arXiv preprint FrXiv:2004.03822, 2020.
Chen-Yo Yu Liu and Samuel Yen-Chi Chen. Federated quantum-train with batched parameter genera- tion, arXiv preprint arXiv:2409.02763, 2024.
Chen- Yu Liu, En-Jui Kuo, Chu-Hsuan Abraham Lin, Sean Chen, Jason Gemsun Young, Yeong-Jar Chang, and Min-Hsiu Hsieh. Training classical neural networks by quantum machine learning. arXiv preprint arXiv:2402. 24422.602.666 2024a.
Chen-Yu Liu, En-Jui Kuo, Chu-Hsuan Abraham Lin, Jason Gemsun Young, Yeong-Jat Chang, Min- Hsiu Hsieh, and Hsi-Sheng Goan. Quantum-trant train: Rethinking hybrid quantum- classical machine learning in the model compression perspective. arXiv preprint arXiv:2405. 11304, 2024b.
Chen-Yu Yu Liu, Chu-Hsuan Abraham Lin, Chao-Han Huck Yang, Kuan-Cheng Chen, and Min-Hsiu Hsieh. Qur:: Toward practical quantum reinforcement learning via quantum-train, arXiv preprint arXiv:2407.06103. 2024c.
Junhua Liu, Kwan Hui Lim, Kristin L Wood, Wei Huang, Chu Guo, and He-Liang Huang. Hybrid quantum-classical convolutional neural networks. Science China Physics, Mechanics Astron- omy, 64(9)220031,, 2021.
Shih- Yang Liu, Chien-Ye Yi Wang. Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang- Ting Cheng. and Min- Min-Hung Chen. Dora: Weight-decomposed low-rank adaptation. arXiv preprint ar Xiv:22402.0935: 2024d.
Xinyin Ma, Gongfan Fang, and Xinchao Wang. LIm-pruner: On the structural pruning of large language models. Advances in neural information processing systems, 36:21702-21720, 2023.
Andrea Mari, Thomas R Bromley, Josh Izaac, Maria Schuld, and Nathan Killoran. Transfer learning in hybrid classical-quantum neural networks. Quantum, 4:340, 2020.
Jarrod McClean, Sergio Boixo, Vadim N Smelyanskiy, Ryan Babbush, and Hartmut Neven. Bar- plateaus in quantum neural network training landscapes. Nature communications, 9(1):4812, 2018.
Kosuke Mitarai, Makoto Negoro, Masahiro Kitagawa, and Keisuke Fujii. Quantum circuit learning. Physical Review A, 98(3):032309, 2018
Adrián Pérez-Salinas, Alba Cervera-Lierta, Elies Gil-Fuster, and José I Latorre. Data re-uploading for a universal quantum classifier. Quantum, 4:226, 2020.
John Preskill. Quantum computing in the nisq era and beyond. Quantum, 2:79, 2018.
Jun Qi, Chao-Han Huck Yang, Pin- Yu Chen, and Min-Hsiu Hsich. Theoretical error performance analysis for variational quantum circuit based functional regression. npj Quantum Information, (1):4, 2023.
Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models unsupervised multitask learners. OpenAl blog. 1(8):9, 2019.
Maria Schuld and Nathan Killoran. Quantum machine learning in feature hilbert spaces. Physical review letters, (24(4))040504, 2019.
Maria Schuld, Ville Bergholm, Christian Gogolin, Josh Izaac, and Nathan Killoran. Evaluating analytic gradients on quantum hardware. Physical Review A, 99(3):032331, 2019.
Maria Schuld, Ryan Sweke, and Johannes Jakob Meyer. Effeect of data encoding the expres- sive power of variational quantum- leaaning- models. Physical Review A, 103(3):032430, 2021.
14

---

Published as a conference paper at ICLR 2025
Jasminder S Sidhu and Pieter Kok. Geometric perspective quantum parameter estimation. AVS Quantum Science, 2(1), 2020.
Sukin Sim, Peter D Johnson, and Alán Aspuru-Guzik, Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classial algorithms. Advanced Quantum Technologies, 2(12):1900070, 2019.
Mingjie Sun, Zhuang Liu, Anna Bair, and Zico Kolter. A simple and effective pruning approach for large language models. arXiv preprint arXiv:2306. 2023.
Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhu- patiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00/ 18, 2024.
Hugo Touvron, Louis Martin, Kevin Stone. Peter Albert, Amjad Almahairi, Yasmine Babaci, Niko- lay Bashlykow, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open founda- tion and fine-tuned chat models. arXiv preprint arXiv:2307.09288 2023.
Hanrui Wang, Yongshan Ding, Jiaqi Gu, Zirui Li, Yujun Lin, David Z Pan, Frederic T Chong, and Song Han. Quantumnas: Noise-adaptive search for robust quantum circuits. The 28th IEEE International Symposium High- Piiho-Perfomance Computer Architecture (HPCA-28), 2022.
Chuhan Wu, Fangzhao Wu, Tao Qi, Yongfeng Huang, and Xing Xie. Noisytune: A little noise help you finetune pretrained language models better. arXiv preprint arXiv:220. 2022.
Chao-Han Huck Yang, Jun Qi, Samuel Yen-Chi Chen, Pin-Yu Chen, Sabato Marco Siniscalchi, Xiaoli Ma, and Chin-Hup Lee. Decentralizing feature extraction with quantum convolutional neural network for automatic speech recognition. In Proc. ICASSP, pp. 5523-6527. IEEE, 2021a.
Chao-Han Huck Yang, Yun-Yun Tsai, and Pin-Yu Chen. Voice2series: Reprogramming acoustic models for time series classification. In International conference on machine learning, pp. 11808- 11819. PMLR, 2021b.
Kaining Zhang, Liu Liu, Min-Hsiu Hsieh, and Dacheng Tao. Escaping from the barren plateau via gaussian initializations in deep variational quantum circuits. Advances in Neural Information Processing Systems, 35:18612-1862,, 2022.
15

---

Published as a conference paper at ICLR 2025
A APPENDIX: A DISCUSSION ON MODEL COMPRESSION
Model compression is a critical and evolving area of research aimed at enabling efficient training and inference in machine learning models. Common techniques include quantization (Dettmers et al., 2022; 2024; Frantar et al., 2022), pruning (Ma al., 2023; Sun et al., 2023), and the PEFT methods discussed in the main text. Quantization reduces memory and computational costs by lowering the precision of model weights, while pruning removes less significant weights, thereby reducing the overall parameter count. The QPA framework introduced this work, by "generating" the parameters of PEFT methods, can be seamlessly integrated with other compression techniques, such as quantization and pruning. This combination enhances its practical applicability and opens promising avenues for further exploration of the QPA approach in the context of model compression.
A.1 EFFICIENT LLM SELECTION FOR QPA
We provide a detailed rationale for selecting Gemma-2 and GPT-2 as the focus models. Prioritizing parameter-efficient models, we chose those that are both open-source and commercially accessible to ensure broad applicability and seamless integration into various systems. Given that QPA elim- inates the need for quantum hardware during the inference stage, making QML more practical, we also focused on selecting classical models that are widely available and have manageable hardware requirements.
While the main text presents results for GPT-2 (80M), Table. also includes QPA LoRA results for GPT-2 XL (1.5B), which exhibit similar trends, demonstrating QPA's ability to reduce training parameters while maintaining performance comparable to other PEFT methods.
Although the proposed QPA is applicable to any LLM and PEFT method (as outlined in See. 3), Gemma-2 (2B) was selected for this study it offers the best balance between performance and resource efficiency given current computational constraints, whereas models with over 70B param- eters remain beyond the scope of this work. Future research will explore the application of QPA to these larger models.
Table 3: Training parameters and testing perplexity for GPT-2 XL (1,5B) using LoRA and QPA methods, with emphasis on configurations achieving the most significant parameter reductions.
PEFT Method
GPT-2 XL
# Params (%)
PPL
LoRA
0.12
1.474
QPA LoRA setting (Ours)
0.07
1.485
QPA LoRA setting (Ours)
0.09
1.475
QPA LoRA setting (Ours)
0.13
1.469
A.2 QUBIT NUMBER LIMITATIONS OF NON QUANTUM PARAMETER GENERATION METHODS
While is possible to generate parameters for tuning tasks using conventional QML methods, that replacing the PEFT methods with VQC modules, key difference lies in the output size. For an output of size n, conventional QML utilizes the expectation value the Pauli-z operator, (W())) o= (1) (0)). for each qubit, resulting in qubit requirement of n, described in Eq. 14 of (Mari et al., 2020). In contrast, quantum parameter generation leverages the measurement probabil- ity (dx ((6:///(0 ()) for each basis, reducing the qubit requirement to [log, n²]
In practical terms, the qubit usage in the PEFT experiments presented in this study ranges between and 11 qubits. If conventional QML were employed, the required qubit count would scale exponen- tially, from 24 to 2 an impractically large number that would make conventional QML infeasible for PEFT applications.
16

---

Published as a conference paper at ICLR 2025
B DISCUSSION ON ERROR PERFORMANCE
Prior works have examined the theoretical error performance VQC regression tasks (Qi et al., 2023) and classification tasks (Du et al., 2021b). For regression, the representational capacity is bounded by (Eq. 11 in (Qi et al., 2023)):
611
CD(ft) = (x) Tir (IE (x; O ege: 0 S
VU + +
(1I)
where U represents the number of qubits and M the number of measurement shots, While our quan- tum parameter generation framework diverges from traditional quantum machine learning method- ologies, a promising direction for analyzing the approximation error of the QPA in estimating PEFT parameters may guided by insights from the universal approximation theorem. Specifically, the representation power of pre-trained large language models (LLMs) could leverage population risk estimation, as outlined in previous theoretical work on parameter-efficien learning with Wasserstein measurements in Hilbert space (Yang et al., 2021b). In particular, the dimensionality of classical hidden neurons may align with that of the Hilbert space, utilizing fewer qubits and quantum gate pa- rameters. This alignment suggests that quantum approach may achieve comparable approximation accuracy with fewer parameters than classical counterparts as one perspective for future studies.
C TRAINING HYPERPARAMETER CONFIGURATION
In this section, we provide the training hyperparameter configuration used for the results presented the main text. Notably, a represents the scaling factor in the low-rank adaptation methods. All experiments were conducted on NVIDIA V100S and NVIDIA H100 GPUs.
Table 4: Hyperparameter configurations of LoRA and QPA LoRA for fine-tuning GPT-2 and Gemma-2 with WikiText-2 dataset.
LoRA
QPA LoRA
Hyperparameters
GPT-2
Gemma-2
GPT-2
Gemma-2
2r
2r
Dropout
0.05
0.0
0.05
0.0
Optimizer
AdamW
AdamW
LR
le-5
le-5
LR Scheduler
Linear
Linear
Batch size
1
Warmup Steps
0
Epochs
5
Table 5: Hyperparameter configurations of DoRA and QPA DoRA for fine-tuning GPT-2 and Gemma-2 with WikiText-2 dataset.
DoRA
QPA DoRA
Hyperparameters
GPT-2
Gemma-2
GPT-2
Gemma-2
a
2r
2r
Dropout
0.0
0.0
Optimizer
AdamW
AdamW
LR
2e-6
2e-6
LR Scheduler
Linear
Linear
Batch size
1
1
Warmup Steps
100
100
Epochs
5
17

---

Published as a conference paper at ICLR 2025
Table 6: Hyperparameter configurations of PT and QPA PT for fine-tuning GPT-2 and Gemma-2
with WikiText-2 dataset.
PT
QPA PT
Hyperparameters
GPT-2
Gemma-2
GPT-2
Gemma-2
Dropout
0.0
0.0
Optimizer
AdamW
AdamW
5e-6
le-6
Scheduler
Linear
Linear
Batch size
1
Warmup Steps
0
0
Epochs
5
Table Hyperparameter configurations of FFA and QPA FFA for fine-tuning GPT-2 and Gemma-2 with WikiText-2 dataset.
FFA
QPA FFA
Hyperparameters
GPT-2
Gemma-2
GPT-2
Gemma-2
Dropout
0.0
0.0
Optimizer
AdamW
AdamW
LR
5e-6
5e-6
LR Scheduler
Linear
Linear
Batch size
1
Warmup Steps
0
0
Epochs
10
10
D QPA APPLIED AT DIFFERENT LORA RANKS
In Sec. 4.1, to maintain clarity in the main text, we presented results only for QPA applied LoRA and DoRA ranks of 4. In this appendix, we provide the full set of results in Fig. 5, showing QPA applied across various LoRA and DoRA ranks. Additionally, it can be observed that different val- ues of 7mmpp may yield distinct optimal LoRA and DoRA ranks. Notably, the optimal LoRA rank identified Sec. 4.2 was based on fixed mmlp for simplicity.
GPT2
Gemman
GPT-2
Gemma.2 2
1.62
1:00
2.50
rm
OP%
(9A ra
30
8.5
1.0
Figure 5: Full perplexity comparison of GPT-2 and Gemma-2 models versus the number of trainable parameters for LoRA, DoRA and QPA, evaluated on the WikiText-2 dataset. This figure shows the complete results with QPA applied across different LoRA and DoRA ranks, complementing the partial results presented in the main text.
E ON PENN TREEBANK DATASET
While the main text presents results obtained on the WikiText-2 dataset, we extend our analysis to showcase the broader applicability of QPA across additional datasets. In this section, report sults of QPA applied to LoRA, Prefix Tuning (PT), and Ferdard Adapter (FFA) on the Penn Treebank dataset. The findings indicate that QPA achieves its strongest advantage in the lower-
18

---

Published as a conference paper at ICLR 2025
parameter regime for LoRA, consistently outperforms PT across all parameter ranges, and demon- strates comparable performance to FFA with a reduced number of trainable parameters. These observations align with the results reported in the main text for the WikiText-2 dataset.
Gemman-
Gemman)
Gemman3
Trcebank
Lofa
+ Fhs
1.30
r
OPR
+--
1.30
1.28
Thating
126-
1.21
1.24
1.20
1.32
1.00
107
10"
10'
30a
10"
121
12
Trainable Parameterrs
Tareel Paransters
Trammbble Paramition
Trarable Parametera
Figure 6: Testing perplexity of GPT-2 and Gemma-2 models versus number of trainable param- eters on the Penn Treebank dataset. The comparison includes LoRA and QPA applied at different LoRA ranks (r = 1,2, and 4). The third subplot compares QPA with PT, and the fourth compares QPA with FFA, further illustrating QPA's competitive performance in various parameter configura- tions.
F EFFECTS OF DIFFERENT CIRCUIT ANSATZ
In the main context, the usage of the Ry circuit inspired by the fact that the rotation Ry produces quantum states with real amplitudes. This contrasts with Rx
cos(
sin(")
sin(
cos( (
cos(
-isin( 8
and Rz Rz (5 e/2
(
0 which involve complex numbers. Since the
-isin
cos( (
ultimate goal is to generate the parameters for the PEFT methods, which are typically real numbers, this rationale led us select the Ry circuit in the main content.
While the quantum circuit ansatz in the main content is constructed as a combination of Ry and CNOT gates, it is also possible to explore alternative circuit ansatz to potentially improve perfor- mance. Similar to the construction of the R CNOT ansatz in the main content (Eq. 1), alternative ansatz be developed by replacing the parameterized Ry gate with other parameterized gates, such as Rx:
N
(0))
II CNOT II
(0!)))
(Rx CNOT circuit).
(12)
j=1
And the circuits combined with Rz gates:
N II
N-1 II 1=1
N II j=1
ne'x (
(())))- = II
CNOT #+1
1+11 (0
Re
CNOT
++1
10
j=1
(Rx Rz + CNOT circuit),
(13)
N N-1
N II
N N-1
II Ry (o)m)))
N
(0)) =
II
CNOT #+1
R (1)
II
CNOT 1+1
(Ry Rz + CNOT circuit).
(14)
In Fig. 7, the LoRA results from Fig. are extended to include an investigation of different circuit constructions, described earlier. Notably, the overall performance differences minimal, sug- gesting that the choice of circuit construction has only a minor impact under ideal conditions. The influence of more realistic conditions will be examined in detail in the following appendix section.
19

---

Published as a conference paper at ICLR 2025
GPT-2
LoRA
Testing perplexity
1.62
Ry CNOT (main content)
Rx CNOT
1.60
RxRz + CNOT
RyRz + CNOT
1.58
1.56
10a
106
Trainable Parameters
Figure 7:
Testing perplexity of GPT-2 versus the number of trainable parameters on different circuit ansatz. The comparison includes LoRA and QPA applied at LoRA rank (r 4).
G EFFECTS OF FINITE MEASUREMENT SHOTS AND NOISE
In the main content, the amplitudes and measurement probabilities of the basis states are computed exactly. Although the implementation actual quantum hardware is left for future work, it is possi- ble to simulate QPA performance on a real quantum computer by accounting for finite measurement shots and incorporating noise model based on the real quantum hardware, On real quantum com- puters, measurement probabilities are derived from a finite number of measurement shots. The higher the number of shots, the more accurate the probability estimates. To understand the scaling behavior of the required measurement shots, we can draw parallels to tasks that approximate one quantum state with another. Based on theoretical findings from quantum fidelity tomography, the goal is to achieve fidelity (((7), (o)) 2 1 - between the output state (ạ) and an unknown state h2), with a given infidelity e. Prior work suggests that the sufficient number of measurement shots
shb 0 ( log
2
)7))
2N
(15)
(Haah al., 2017), where N represents the number of qubits.
As the number of measurement shots scales exponentially with the system size N, adopting a lin- ear scaling strategy with respect 2N emerges a practical approach to improve both train- ing and testing performance in larger systems. In Fig. 8, the LoRA and QPA results for GPT-2 from Fig. are analyzed under finite measurement shots. By comparing measurement shot counts Nshoo E {10 x 2 20 x 2N 40 x 2N,, where N is the number of qubits, it can be observed that increasing the number measurement shots leads to improved results. As expected, the outcomes progressively approach the exact measurement results the shot count increases. Specifically, the results for nishor = 40 x 2N are notably close to the exact measurement results certain cases. The number of qubits N in Fig. 8, corresponding to the progression from the smallest number of trainable parameters to the largest, is (10, 9, 8, 7, 6, 5), as indicated Fig. 4(a).
Consequently, the ability to swiftly gather measurement data is critical for the effective application of the QPA method. Generative models present a viable alternative by simulating measurement outcomes efficiently (Ahmed et al., 2021), which can alleviate the burden of needing exponentially large numbers of shots. By utilizing generative models, it becomes possible to reduce computational complexity and enhance the practicality of quantum state tomography in large-scale systems, thereby increasing the feasibility of applying QPA in real-world scenarios.
As discussed earlier, by simulating finite measurement shots and incorporating a noise model based on real quantum hardware, it is possible to analyze the performance behavior of QPA on an actual quantum computer. In this appendix section, we use noise models derived from the IBM quantum computers ibm_torino and ibm_fez in our finite measurement shot simulations 3
IIBM Quantum provides noise models based on the properties of real hardware back- endsthtops: war.ooss.uuunuuu. i bbm com/com//a www.api.ccppp//cc /qi sk t/ /9l///i/skk it. provi ders.der.... noi se Noi seMode1.
20

---

Published as a conference paper at ICLR 2025
GPT-2
Exact measurement 10 2
10a
Ouea 20
Testing powrgne
Ryw
10.
2x
6x100
10a
1 3 x 105
Figure 8: Testing perplexity of GPT-2 versus the number of trainable parameters on different number of measurement shots with Ry+ CNOT ansatz. The comparison includes LoRA and QPA applicd at LoRA rank (r = 4).
GPT-2
Nossless (Ry CNOT)
Noisetess (Rx CNDT)
Agondded Buise
10a
(fy CNOT)
torine noise model CNOTI
ibm, fez noke movel (fly (NOT)
ibm note (Rx CNOT)
10:
10
6x 10
10a
2 10
x 10
Parameters
Figure 9: Testing perplexity GPT-2 versus the number of trainable parameters on different noise setting with Ry + CNOT and + CNOT ansatz. The comparison includes LoRA and QPA applied at LoRA rank (r = 4), where nho is fixed at T.sbot = 20 2
In Fig. 9, the QPA performance results are presented the presence of quantum computer noise models for two circuit constructions: Rx+ CNOT and Ry+ CNOT. In the noiseless case, the Ry circuit outperforms the Rx circuit in overall trends. Interestingly, when noise from torioo and ibm_fez is introduced, although performance decreases slightly in some cases, it improves in most instances. This phenomenon aligns with previous observations in some quantum computing studies, where quantum noise has been shown enhance performance in certain paradigms (Domingo al., 2023).
Similarly, in classical machine learning, studies have demonstrated that small amount of noise can be beneficial for fine-tuning LLMs (Wu et al., 2022). Since the quantum circuit in QPA generates measurement probabilities that are subsequently input into a classical MLP mapping model to pro- duce PEFT parameters. this suggests that quantum noise may play role analogous to the "small noise" effect observed in prior studies, aiding the fine-tuning LLMs, exploring more parameter spaces.
H ON GRADIENT VARIANCE OF QUANTUM CIRCUIT PARAMETERS
The occurrence of barren plateaus is a critical challenge in the training of QNNs (McClean et al., 2018; Zhang al., 2022). Barren plateaus typically arise in learning tasks where the objective the expectation value of some Hermitian operator H, expressed as:
(16) In contrast, our QPA approach deviates from this framework. The objective of QPA is the loss function of target classical model (LLM, in this study). The parameters of this target model updated using PEFT methods, with these parameters being generated by a mapping model that processes information derived from the measurement results of the QNN. Consequently, the output
E(()= (0) (U))))
21

---

Published as a conference paper at ICLR 2025
of our QNN is the measurement result of basis states, rather than the expectation value of a Hermitian operator. As a result, whether the exponential vanishing gradient characteristic of barren plateaus occurs in QPA remains open question.
To investigate whether barren plateaus are present in QPA, we analyzed the variance of the QNN gradient 00 in the QPA-LoRA results for GPT-2, shown in Fig. 10. Notably, significant downward trend in gradient variance is observed with increasing qubit count. This behavior may stem from the fact that QNN gradients are propagated backward through the subsequent mapping model, preventing them from behaving like the expectation value-based objectives typically seen in traditional QML.
Interestingly. however, as the QNN repetition L increases, a slight downward trend in gradient variance observed. This behavior bears some resemblance to both classical deep feedforward neural networks and barren plateaus in QNNs, as described in (Glorot & Bengio, 2010; McClean al., 2018), albeit to a much lesser extent. This suggests that, while QPA does not exhibit barren plateaus in the same way as traditional QML (specifically with respect qubit counts), its gradient dynamics may still reflect certain characteristics both quantum and classical learning paradigms.
0.04
0.03
N
a0 valfance
jP vartance
0.03
0.02
Nm
N 10
0.02
0.01
10
10a
qubits
QNN repetition
Figure 10: Variance of the gradient 00 with respect to the number of qubits (N) and the QNN repetition depth (L).
I ON COMPUTATIONAL TIME
The total execution times for LoRA and QPA, as presented in Fig. 2, are detailed Table 8 and Ta- ble 9, For the LoRA results in Fig. 2, the average batch execution times for classical LoRA and QPA are 0.0154s and 0.0460s for GPT-2, and 0.0207s and 0.0576s for Gemma-2, respectively. Therefore, when accounting for the additional quantum circuit simulation and computational overhead of QPA, its average execution time is approximately three times that of LoRA.
Based on this observation, we can compare the performance of LoRA and QPA under similar total computational time. Specifically, for every epoch of QPA training, LoRA can complete approx- imately 3 epochs. In Fig. 11, we compare
QPA and LoRA under different numbers of training epochs. For GPT-2, since both LoRA and QPA originally undergo epochs of training, the QPA results with epoch serve as a benchmark for comparing QPA's performance under similar total execution time to that of LoRA.
performance
For Gemma-2, the analysis follows a similar rationale. With training epochs set as the baseline, we provide results for 1 and 2 epochs of QPA to estimate its performance under total execution time comparable to LoRA. The results show that, although QPA with a similar total execution time does outperform LoRA the same extent when both methods have the same number of epochs, it still exhibits better performance regions with smaller parameter sizes.
IMPLEMENTATION DETAIL.
This section provides a minimal example of how QPA is applied to LoRA a Gemma-2 model, im- plemented using PyTorch and TorchQuantum. The code snippets demonstrate the key components
22

---

Published as a conference paper at ICLR 2025
Table 8: Training parameters and total execution time for GPT-2 using LoRA and QPA methods. Corresponding to the results provided in Fig. 2
GPT-2 LoRA
GPT-2 QPA
# Params
Total execution time (S)
Params
Total execution time (S)
51025
1696
47248
5965
102050
1677
55656
5520
204100
1695
72512
5223
408200
1712
106264
4910
816400
1700
173808
4570
1632800
1729
308936
4245
Table Training parameters and total execution time for Gemma-2 using LoRA and QPA methods. Corresponding to the results provided in Fig. 2
Gemma-2 LoRA
Gemma-2 QPA
# Params
Total execution time (s)
# Params
Total execution time (8)
258048
3796
72592
13861
516096
3794
173888
11602
1032192
3798
309016
8316
2064384
3690
9252 1119944
575154
4128768
4002
11768
8257536
3816
2201248
8702
of the QPA process, including the modification of the target layer and the generation of low-rank matrices using a quantum parameter generation approach.
class OPA LoRAGenma2 Ian, Modulel:
def Init (self, penma_modell supez LoRkGemaa,, self) init__1
weff.gemmaamnnn madel gemma_maaa
for name, module in self, see.f.gemme_moeee sese moduull)
if =- 'la_head";
10
loye_layer - QPA inodule, r-LoRR__ank, algha-Ioo&_rankx22
(eel..eaee....emmaaaa. www.llf.gemmaaaoeeee name, lore_layez)
12
forward fsel ingat_ida, attention_nee on_mask, labels):
14
15
outputs self, gonde (input_ids, Seceettioommsk-attetteee. labels labels)
16
18
return outputs
In the above example, the head layer modified using the QPA.LerrLayer function, defined as follows:
(PA LoRALayer Module)
def
init (salf, ort origina _aayer, 1phaa
super (QPA LoRALaye,,,, seif) init_
self. fill.originat_laye self.r - self.alpha alpha self.dropout nn Uropout (p=0.0)
original_layer
self.dtype torch. f1oat32 Engure tensors are this type
10
Generate the parametezs of and self. reA_res Moduleeee (et Sriginsl_layes.o weigh.........eee..... 1) 1] ()
12
zsoriginal layer, weight size
14
23

---

Published as a conference paper at ICLR 2025
GPT-2
Gemma-2
LoKA
LoKA-
QPt epach
epach
Testing parp cxty
1.62
Q8A epach
QBA 2 epech
1.46
82
1.60
1.44
1.58
1.42
1.56
1.40
10a
10
10P
10c
107
Trainable Parameters
# Trainable Parameters
Comparison of testing perplexity against the number of trainable parameters for GPT-2 (left) and Gemma-2 (right) models using LoRA and QPA approaches across different epochs.
Figure 11:
16
17
Freeze the original layer's paramoters
19
for param in aelf aelf.origina srriginnl__a laaneal__yeeeaaeee waayer.paraeteersae..
pacam. recam.requires_gree False
21
forward x]
23
gen_weights
sel felFA.oA_ees
26
self, gewerattes toweh.cat..genneeiiii.i
s dim=0) (-i [rsii..rggina Layer. weight.iihtt.t. (3)
4 self.riself.ort oor
28
self. Seat:.genrratee_eelhhttt..
4 self seI._ggeereteeeLLviittttttesee
htt.::eel...iiaalllleee..ao oeye.halleeyer..eiiitttt siie (0) +self.e)
+ get.eraaeee
view oayg size
+ self.s) .tpe dtyp.
30
self. gew.ggnatttd.
4 self wege
Layer_ wer geo.gh..ati aaze vae f.r:)
31
self. gewerattee_eeeggleee.....
self. weiehha view view(aelf.d
4 self. eelf.orrginall_eee...etii
33
batch_size, len, hidden_size - x.size
x_reshaped dropout .view(-1, hidden_size)
35
delta (K_reshaped @
self, wut..ggnerttoddwwighhs...
delta delta (selt.alpha / self.r)
37
delta delta. view.viewwie sbeech sea_len, sell..generateeeLviiitts....... return self. origiooiiiiaallleae. + delta
38
As shown in lines 28 and 30, the low-rank matrices A and B are generated by the QPA_Net object, which implements the method described in Sec. 3. The Qet class is defined as follows:
class OPA Net Module)
def Init (self, vocab_size, hidden_size):
supez Net, self) init_[)
celf.n_sub..e sel felf.ueight_] weights_eennt = int inp.cef] ((vocab_stss hidden_size) se f.n_aub_res
self. self.oat_dimmnie oat_odt__iiiaaa chank_sige
self, batch_size int (np. ceil (self.weight Jei.eeeeii.....eeeeeeeee......
11
self, dropout uropout (p=0.)
12
13
delf.eevice torch. dorchedevioe ("ouda" ("ouda" if torch. cuda. is_avallable() else "opu")
14
self.init. inii__aappinggggn.c.o "Mas"
16
self, wtw.caaaccllllyeeeeo..o = "MUP"
18
www._gubttttgogm iap. (np. log2 ( batchh_si
24

---

Published as a conference paper at ICLR 2025
self. qubitt wolf.n_gubit_..0.
21
celf.g_deptt = een_depth
22
seLf,Quant Stayer (ell.rrte self.n_eubit_apx .to (o
23
24
if sels, inst.iiit,ii mapiiii "MuP":
self hal..MappingNntwockk Moppingtodel (uubt.n [32, 128, 128, 321, + sel pelf:out_din_mpp
27
28
if self, cels.cleess "MIP"; self.fel Linear iseif. dut_dim self welf.out__de dim
30
32
def forwardlael
34
compute_mettoc "checkpoint"
probs__ (alf.guantums)() (). flatten()
probs_ proba_ batch_atzee
39
probs_ tesha_ batchhaizee, 1, 1)
41
qubit cubit_stateds sttatttttttorrt geteette__uiit__aeeeeeeee qugubi,,, self, batch_nize) [:self..eighh_ wtw.://gggt...ooaaa..o.........e device)
45
combined_deta_
proba_t, din=2)
45
prob_val_post_peee processed
47
if compute_method -- "checkpoiat";
48
50
batch_date data combined_ cardddddttttttt______e torcttorohhoo (orchh(0sehel
balch_ raaiiiddlaarruuirr__ggee.
52
checkpoint (self. Nappinggittwork, harpsipnett........aaaaaneeeett batch_data)
54
55
sels.classicel__yyer =. "MLe":
57
htt__va__oot_pprcceeee batch checkpoint (selt.dropout,
pro_
58
prob_vel_post_proeee propssss_proesseee_aatt.t checkpoint (self.fcl,
60
prob_va Loo_val__eos
gest_processed append iprob_val powpp_pooceased_eeee
62
torch. empty_cache
64
prob_val faal_ppst___i_ ptwppoosspoossee_____ list proh_val wal.aall_ssssooeeoooeoe _to_oosstccssee____________ f w.eighttllngg
pro._vel_pott_procesee torch. it dimmc)
67
prob_val_pode por_oo__pptt_ppooseeeed pattaal_tt_ppooeeeeeeee viewt-1) prob_val_post_pree prob_val_past__rrceeee
69
71
torch. wwt.:cuud..ettt_ccceeeee
return prob_val_postt_rreeee
This implementation demonstrates how QPA is applied to generate low-rank matrices using quan- tum parameter genreation, which can be seamlessly integrated into LLMs to improve parameter efficiency.
25


Reviews:
[{"review_id": "I9DBrkYohq", "reviewer": "Reviewer_jv7T", "summary": "The authors propose a novel quantum circuit-based algorithm, termed Quantum Parameter Adaptation (QPA), aimed at generating parameters for classical neural networks. This approach seeks to enable parameter-efficient learning of pre-trained deep learning models by reducing the number of training parameters while preserving model performance. Specifically, they utilize a quantum neural network with tunable parameters to produce a quantum state, whose amplitude under a specific basis is processed by a classical multi-layer perceptron to generate parameters with desired properties (e.g., low rank) for fine-tuning methods. Empirical experiments are conducted on two pre-trained models, Gemma-2 and GPT-2, demonstrating that QPA achieves significant parameter reduction for fine-tuning methods like Low-Rank Adaptation (LoRA), while maintaining or improving performance in text generation tasks.", "questions": "1. Could the authors provide experimental results comparing the performance of QPA with baseline methods while maintaining the same computational complexity?\n2. Could the authors elaborate on the impact of the barren plateau phenomenon in the training of quantum neural networks, particularly concerning the optimization of large language models (LLMs) with 1 billion parameters, which necessitates a substantial number of qubits?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The authors present the Quantum Parameter Adaptation algorithm, which innovatively applies quantum devices to train classical machine learning models. This exploration opens up a new paradigm in quantum machine learning, shifting the focus from using quantum circuits solely as learning models to leveraging them for generating parameters in classical models. This shift in roles between quantum and classical computers enhances the efficiency of classical-quantum hybrid algorithms.\n2. The application of QPA to practical large-scale models such as GPT-2, resulting in improved performance and parameter reduction compared to traditional classical fine-tuning methods, is commendable.", "weaknesses": "1. The authors assert that one motivation for proposing QPA is to mitigate the high computational costs associated with existing fine-tuning approaches by reducing the number of parameters. However, extracting amplitude information from quantum states and training the quantum neural network can be highly computationally intensive due to the inherent challenges of quantum systems and the barren plateau phenomenon. This could introduce significant computational costs during each training epoch, making a fair comparison between QPA and classical fine-tuning methods difficult.\n2. Additionally, as I understand it from convergence theory [1], the number of parameters required for a quantum neural network to represent an arbitrary quantum state scales with the dimension of the quantum system, specifically $4^n$. Thus, to represent a parameterized quantum state for an arbitrary vector of dimension $r(d+k)$—the dimension of the low-rank weight matrix $\\Delta W=BA$ —the quantum circuit would also need to have parameters on the order of $r(d+k)$. In this regard, QPA may not achieve any significant parameter reduction compared to completely classical fine-tuning methods.\n\n[1]. Larocca, Martin, et al. \"Theory of overparametrization in quantum neural networks.\" Nature Computational Science 3.6 (2023): 542-551.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "V5495ZtNhy", "reviewer": "Reviewer_s1Tx", "summary": "This paper introduces quantum parameter adaptation, a quantum parameter generation algorithm that uses quantum neural networks and classical multi-layer perceptrons to generate parameters to help fine-tune classical machine learning models.", "questions": "- Does this technique have any utility if you always need to perform a full strong simulation of the quantum circuits? Either because it is not robust to noise or because you can’t get away with finite measurements.\n   - Have you tried running your method on actual quantum hardware? If not, why not?\n   - How expensive would it be to implement your method in a fault-tolerant manner?\n   - It is unclear to me how much this work pushes the sota forward. For instance, how does it differ from the other cited works? “Using the gradient computation and parameter update rule, the parameter generation process of QPA\nhas been applied to image classification with convolutional neural networks (CNNs) (Liu et al.,\n2024b;a; Liu & Chen, 2024), flood prediction (time series) with long short-term memory (LSTM)\nmodels (Lin et al., 2024), and policy gradient reinforcement learning in CartPole and MiniGrid\nenvironments (Liu et al., 2024c).”\n   - How expensive is it to update the gradient on real hardware?\n   - What compute was used to produce the paper? What was the total wall clock time? How does that compare to the classical methods used?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "Strengths:\n   - Interesting idea (albeit one that has been done before to some extent) pushed further than in past work. Smartly gets around some of the known issues with QML, like the issue with expensive inference.\n   - Brings related work closer to the forefront of classical ML by applying their method to Gemma-2 and GPT-2. \n   - Good use of MLPs and batching to reduce parameter counts.", "weaknesses": "REVISION: The author's rebuttal and revised manuscript have addressed enough of these weaknesses to merit inclusion at ICLR.\n\nWeaknesses:\n   - Misleading claims about fault-tolerant quantum computation: The paper makes several misleading claims about fault-tolerant quantum computing (FTQC) which have the potential to make a uniformed reader think that universal FTQC is right around the corner. It’s not. For instance, the information in the second footnote is wrong. IBM has not demonstrated 12 logical qubits with 288 physical qubits. They’ve discovered a quantum error correcting code with that property. However, actually implementing that code in practice is going to be very hard! Moreover, running this paper’s parametrized quantum circuit (PQC) in a FT manner is going to be very expensive! The PQC requires small-angle Y rotations, which are extremely costly!\n   - No serious discussion of the impact of noise: The paper completely sidesteps the issue of noise. This is especially concerning when the approach is outperformed by classical competitors in the noiseless setting on certain problems. \n   - No theoretical performance guarantees. Not necessarily bad, but it’s not great when you don’t have amazing experimental results (the paper has no experimental results, just simulations).\n   - I am not sold at all on their approach to using synthetic data to get around the issue of having finitely many shots…generative models are expensive to train too! \n\n\nSome minor nitpicks:\n   - It is an open question if quantum computing excels in optimization. Change the claim in your introductory paragraph, or at least soften it.\n   - “This hybrid approach is especially promising in quantum machine\nlearning (QML), where it can enhance the training and fine-tuning of large models.” Also not evident that QML can help with the training or fine-tuning of large models. Isn’t that the whole point of this paper? Temper this claim.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "tLI6iXEOdS", "reviewer": "Reviewer_tsMN", "summary": "The paper proposed quantum parameter adaptation (QPA), a method that combines quantum systems with classical models to enhance parameter-efficient fine-tuning in machine learning, especially for LLMs like GPT-2 and Gemma-2. Unlike traditional quantum machine learning methods that require quantum hardware for both training and inference, this approach uses quantum resources exclusively during the training phase to generate parameters for classical models, eliminating the need for quantum hardware at inference. This design enhances scalability and resource efficiency on classical hardware, addressing practical deployment concerns.", "questions": "1.\tWould the algorithm perform equally well if the quantum component were replaced with a classical system? Since the role of the parameterized quantum circuit here is to produce an intermediate hidden state, could a classical neural network serve as an alternative? Given the challenge of barren plateaus in quantum machine learning, a classical neural network might avoid these issues and potentially improve performance.\n2.\tIs there potential to reduce the need for full quantum state tomography in QPA? Could approaches like quantum shadow tomography, which require only partial measurement data, be used to extract sufficient information from the quantum state while reducing computational costs?\n3.\tThe current parameterized quantum circuit design relies on CNOT and RY gates, which restrict the quantum state to real values and consequently limits the Hilbert space it explores. Have the authors experimented with more complex circuits to explore the full Hilbert space, and if so, does this yield performance improvements?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "QPA achieves significant reductions in the number of trainable parameters required for fine-tuning LLMs while maintaining performance, making it highly relevant for parameter-efficient learning. This reduction makes the method resource-efficient and feasible for real-world application. In addition, the paper presents an elegant integration of quantum and classical computing. The authors demonstrate QPA’s effectiveness on state-of-the-art LLMs, contributing meaningfully to the rapidly advancing field of LLM research.", "weaknesses": "From my understanding, the quantum component of QPA does not appear to harness the inherent advantages of quantum machine learning. Since the quantum state must be fully characterized before classical post-processing, this process typically requires full quantum state tomography, involving an exponential number of measurements with respect to the number of qubits. This requirement is likely more computationally intensive than classical simulation, eliminating any quantum advantage. In this regard, QPA might better be described as a quantum-inspired algorithm rather than a quantum machine learning algorithm, as it does not appear to yield a speed-up or other quantum advantages over classical simulations. The authors themselves acknowledge in Appendix B that modeling the quantum state using a classical generative model could offer a more practical alternative.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "tol4SYF3B6", "reviewer": "Reviewer_Y4nw", "summary": "The paper introduces Quantum Parameter Adaptation (QPA), a novel approach for parameter-efficient learning that combines quantum neural networks (QNNs) with classical machine learning to generate parameters for fine-tuning large models. The QPA method utilizes quantum circuits to generate classical model weights, allowing for significant parameter \nreduction without compromising performance, as demonstrated with Gemma-2 and GPT-2 case studies. The method enables practical use of quantum machine learning by decoupling quantum hardware requirements from the inference phase, thus making inference feasible on classical systems. The results show that QPA can effectively reduce the number of parameters required for methods like Low-Rank Adaptation (LoRA), while maintaining or improving model performance, indicating its potential as a scalable and efficient quantum-classical hybrid solution for large-scale learning tasks.", "questions": "1. Lack of comparison with other rotation gates: The author mainly chose the combination of RY gate and CNOT gate, but there is a lack of detailed comparative analysis in the article. Why is the RY gate more suitable for this specific task, while the RX and RZ gates are not good enough? The author needs relevant experiments to verify the advantages of the RY gate over other gates.\nRationality of the selection of rotation gates: RX, RY and RZ gates are all single-bit rotation gates, why does RY have a better effect in this scenario? Is there a clear mathematical or experimental basis to show that the efficiency and effect of the RY gate in quantum parameter generation is better than RX or RZ? If not, does this mean that the author's choice of the RY gate is more based on experience rather than theoretical support?\n2. Performance in noisy environments: Although the RY gate is considered to perform better in capturing the rotation characteristics of quantum states, quantum hardware has noise and errors in actual operation. Have you compared the robustness of different rotation gates in actual quantum hardware? Especially when considering quantum noise, is the RY gate still the best choice? At the same time, the performance of QPA in actual quantum hardware remains to be considered.\n3. Lack of discussion on time complexity: Although QPA performs well in reducing the number of parameters, the paper lacks a detailed discussion on the running time of the quantum circuit when generating parameters. Does the generation and measurement process of the quantum circuit bring additional time overhead? Does this additional time complexity offset the improvement in training efficiency brought by parameter reduction?\nCompared with the classical PEFT method, is there a significant time overhead in the process of QPA using quantum circuits to generate parameters? Do these differences have a significant impact on the practical application of models at different scales? In practical applications, the time efficiency of the model is one of the important considerations. Even if the number of parameters is reduced, if the time complexity of the quantum circuit is high when generating parameters, this may affect the efficiency and scalability of the overall system. The author should provide more quantitative analysis to evaluate the overall cost-effectiveness of the QPA method in terms of time and computing resources.\n\n4. In more complex scenarios, how does QPA compare to traditional QML methods? : The paper shows the efficiency of QPA in reducing parameters of large models such as GPT-2 and Gemma-2. However, how does QPA perform when extended to larger models such as GPT-3 or larger? Does quantum parameter generation encounter scalability issues in such scenarios?\n\n5. Best choice of parameter configuration: How to determine the best block size (nmlp) and number of QNN repetitions (L) for different PEFT methods? Is there a general method to determine these hyperparameters for other models?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The paper proposes the Quantum Parameter Adaptation (QPA) method, which is a new method that combines  quantum neural networks (QNN) with classical multi-layer perceptrons to generate The parameters of the fine-tuning method demonstrate the efficiency in parameter reduction. \n2. QPA separates quantum computing from the inference stage, allowing the model to perform inference without  relying on quantum hardware, greatly reducing deployment complexity and thus having practical application value for classical hardware inference. \n3. Experimental results show that QPA can significantly reduce the number of parameters while maintaining or slightly improving model performance. In contrast, methods such as LoRA, DoRA,  and Prefix Tuning (PT) are highly efficient in parameters. The performance in learning tasks is not as good as QPA, highlighting its high efficiency. \n4. The authors extend the QPA method to large models such as GPT-2 and Gemma-2, significantly expanding the scope of previous quantum parameter generation studies. \n5. QPA allows flexible exploration of different parameter configurations, improving its \nadaptability in different models and parameter efficient fine-tuning (PEFT) methods.", "weaknesses": "1. The study assumes that the measurement probability is exact and does not consider noise, which may not accurately reflect the situation where a finite number of measurements are required in the actual quantum hardware environment. Although the impact of this limitation on performance is discussed, the problem is not completely solved. It is possible to consider introducing some simulated noise models to verify the robustness of the proposed QPA.\n2. The paper mentions that QPA uses RY and CNOT gates to build quantum circuit ansatz, but lacks a detailed explanation of why this ansatz structure is chosen. It is recommended that the author add a detailed argument for the choice of ansatz and compare the effects of different quantum gate combinations to ensure the rationality of the current choice.\n3. The method uses the gradient obtained from quantum measurements, which may introduce additional complexity in the training process, especially when implemented on actual quantum hardware, due to the presence of parameter offsets and measurement noise.\n4. The paper mentions that the theoretical analysis of the convergence behavior, trainability and learnability characteristics of QPA will be addressed in future research, which shows that there is a gap in the current understanding of the long-term effectiveness of QPA.\n5. More shortcomings can be found in the Questions section.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "PI5tBIXCf8", "reviewer": "Reviewer_KJS2", "summary": "The paper presents a novel approach for quantum parameter generation aimed at providing a quantum-classical solution for fine-tuning LLM's parameters.  Authors conduct simulation on benchmark datasets to assess performance compared to traditional fine-tuning techniques like LoRA and DoRA. Results indicate improvements in reducing the number of parameters while maintaining or surpassing the performance of existing PEFT methods.", "questions": "Reviewer would be grateful if the authors could discuss the following: \n\nGiven that the primary idea of this paper aims to leverage the exponential dimensionality of quantum states to represent the parameter space of LLMs. There exists a parallel in tensor network [1,2] theory that serves a similar purpose: the most successful application of tensor networks in physics has been to approximate exponentially large vectors arising in quantum mechanics.\n \nThe question is that might it also be feasible to explore the application of tensor network's theories and methodologies as an alternative to the currently resource-constrained and large-scale unavailable quantum computing? \n\nAdditionally, could the authors utilize certain theoretical insights (e.g. from tensor network research) to investigate why the proposed method achieves superior performance compared to traditional fine-tuning techniques such as LoRA and DoRA, rather than relying solely on empirical evidence? \n\nThis discussion could significantly enhance the theoretical underpinnings of the paper and provide a more robust framework for understanding the advantages of the proposed approach.\n\n[1] Stoudenmire E, Schwab D J. Supervised learning with tensor networks[J]. Advances in neural information processing systems, 2016, 29.\n\n[2] Liu Z, Yu L W, Duan L M, et al. Presence and absence of barren plateaus in tensor-network based machine learning[J]. Physical Review Letters, 2022, 129(27): 270501.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "The authors introduce an new framework that aims to bridge the gap between classical machine learning and quantum computing.", "weaknesses": "1. Efficiency Concerns: The proposed quantum parameter generation method, while designed to reduce the need for quantum hardware during inference, still relies heavily on quantum neural networks (QNN) during training. This raises critical questions regarding the efficiency of the overall process. Specifically, the optimization of quantum neural network parameters is prone to challenges such as barren plateaus, which can significantly hinder the training process. The authors do not sufficiently address how these issues may impact the efficiency of fine-tuning parameters of classical large models, particularly given the complexities associated with high-dimensional optimization landscapes typical of QNN.\n\n2. The inputs of the mapping model necessitates a precise value of the corresponding measurement probabilities of the basis of quantum states. Typically, these probabilities can only be approximated through repeated measurements and averaging, which introduces another layer of complexity. The need for multiple measurements raises concerns regarding the time overhead involved. The paper does not adequately discuss the potential delays that may arise from extensive measurement requirements, especially in the context of noisy intermediate-scale quantum (NISQ) devices where measurement fidelity can be compromised by inherent noise. Furthermore, the implications of limited measurement shots on the accuracy of estimated probabilities and the subsequent effect on LLM's fine-tuning are not sufficiently explored.\n\nAlthough the authors mention the limitations of finite measurement shots in Appendix B, the reviewer believes that providing sufficient experimental results, including finite measurements and noise-affected simulations, is essential for demonstrating the feasibility of the proposed method in the paper.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)