Development of Neural Network-Based Optimal Control Pulse Generator for Quantum Logic Gates Using the GRAPE Algorithm in NMR Quantum Computer

Developing the software components of quantum computers plays a crucial role in achieving the ambitious goal of building scalable, fault-tolerant, and universal quantum computers. Today, alongside efforts to enhance the quality of the quantum layer and address the challenges of hardware architecture across various platforms, intense research focuses on quantum error correction, error mitigation, and quantum control methods. These methods help compensate for the unavoidable hardware defects.

One of the primary challenges in scaling up contemporary quantum computers is achieving high gate fidelities, which increases the depth of quantum circuits. Additionally, to achieve a fault-tolerant regime, gate fidelity must surpass a specific threshold. Enhancing gate fidelity beyond this threshold reduces the overhead qubits required for effective quantum error correction.

There are several factors that limit the fidelity of quantum logic gates, including the imprecision of classical control instruments, interactions of qubits with the environment, and material imperfections and manufacturing defects in the quantum hardware layer. Most of these factors are related to the platform used to set up the quantum processor. For instance, cross-talk between qubits and the inevitable evolution of qubits due to qubit-mediated interactions during single-qubit gates are significant issues. These challenges arise even in closed quantum systems and are prevalent across various platforms, including NMR and superconducting systems. This is where optimal quantum control methods can play a crucial role in enhancing gate fidelities.

The NMR platform is an excellent choice for testing quantum control ideas. Firstly, bench-top NMR spectrometers are now accessible in many university laboratories, making them convenient for research. Additionally, due to their weak magnetic field, advanced pulse shaping is essential for optimal control in bench-top NMR quantum computers. Secondly, the results obtained can be readily applied and extended to other platforms with similar Hamiltonians, such as controlling superconducting qubits in a quantum bus resonator.

Quantum logic gates are implemented on the NMR platform by applying RF magnetic field pulses, where, the central frequencies of these pulses close to the Larmor frequencies of different nuclei [1, 2, 3]. Extensive research has been conducted to determine the various pulse shapes required to implement desired operations with high fidelity [4, 5, 6, 7, 8]. One method for finding the optimal pulse shapes for specific logic gates involves using optimal control theory, which offers several approaches [9, 10, 11, 12, 13]. A notable numerical approach within this theory is the GRAPE algorithm [14]. This method focuses on finding the optimal pulse shapes for specific quantum logic gates (e.g., S, T, H, X, Y, and Z) [15]. Once the pulse shapes for these basic gates are generated, which can take a relatively long time, they are registered in the compiler. These registered pulses are then used to implement any other arbitrary gates in the algorithm.
A more sophisticated goal, particularly crucial in the NISQ era, is to extend this approach to design pulse shapes for directly implementing arbitrary gates without decomposing them into basic gates (i.e., implementing any arbitrary single-qubit gate with a single pulse) [16]. This is where neural networks come into play. Now, the network itself can be considered part of the compiler, allowing for the generation of pulses for any arbitrary gates in a reasonable time, i.e., compile time.

In recent years, there has been a surge in research exploring the application of machine learning algorithms within the realm of quantum optimal control theory [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]. Also, there has been significant research in developing NMR or MRI RF control pulse designs using neural networks by utilizing the excitation profile as a training set [30, 31, 32, 33, 34, 35]. Furthermore, the usage of neural networks in the shimming of NMR spectrometer is discussed [36, 37, 38]. In this work, we have developed the neural network, by applying the GRAPE algorithm for sampling to train networks for implementing the logical gates in NMR systems. The concept of developing control pulses can be expanded through the use of neural networks, as explained here [16, 39]. We used and extended the main ideas presented in [16, 39], by developing the method of sampling to train the neural network and testing it in an NMR quantum computing implementation. Utilizing a neural network, we can input the desired operation and, in return, receive the pulse shape as the output. This provides us with a versatile tool capable of generating pulse shapes for any arbitrary gates in a reasonable time, rather than being limited to a single specific gate, which is the limitation of the GRAPE algorithm [16, 39].
To design such a network, a training set is required. For efficient training, we focus on generating phase-only control pulses [40, 41]. One straightforward strategy involves generating a series of random pulses and computing the resulting operations they enact on the system. Consequently, we obtain numerous ordered pairs: the first element is the operation, and the second is the corresponding pulse shape. With this training set, we can proceed to train a neural network. However, when we applied this approach to a three-qubit NMR system, the results were sub-optimal, and the error rates failed to decrease satisfactorily. We then considered utilizing the GRAPE algorithm to develop a training set for the neural network. This time, we selected a variety of single-qubit gates at random and employed the GRAPE algorithm to determine the optimal control pulses for their implementation. A critical aspect of using the GRAPE algorithm for developing these pulses was initiating the search from the same starting point to find the optimal results. After calculating the cosine similarity between the randomly generated pulses in the previous approach, we found that the similarity was not particularly significant. By beginning from a same point in the GRAPE algorithm to develop pulses for the desired gates, we effectively narrowed down a specific region in the space of control parameters. This means that within this region, the pulses are closely related to one another, Fig.1.

As we will demonstrate, the cosine similarity between the resulting pulses has significantly improved. This approach helps us to focus on data around a specific point in the solution space. Intuitively, starting from a random point in each GRAPE iteration causes the algorithm to converge to different minima with the same fidelity value. In a problem with multiple, or even infinitely many, local minima, it is crucial to limit our analysis of the dynamic system to a specific local solution. Ignoring this necessity results in severely non-smooth data geometry, preventing a simple, feasible neural network from finding any patterns within the feature space.
Therefore, initializing the GRAPE algorithm at a specific point before generating the training set is mandatory; otherwise, our mean squared error (MSE) regression optimization algorithm will struggle to fit the neural network to the data. Cosine similarity served as an appropriate criterion for analyzing the smoothness of our generated data. Initializing the GRAPE algorithm from the same point significantly increased this criterion, validating our strategy for generating a smooth training data set. Consequently, the development of a neural network with this training set proved successful.
We now possess a neural network that, upon inputting your desired single-qubit gate, outputs the shape of the pulse. Another achievement of this neural network approach is its ability to implement complicated operations in a single pulse. This method is advantageous over executing gates sequentially, particularly in the NISQ era, where the fidelities of individual gates would compound, resulting in a reduced overall fidelity. By directly generating the operation, we can achieve it with significantly higher fidelity and fewer steps.

For the n-qubit NMR system with homo-nuclear molecule, one can demonstrate that if we are in the liquid regime and at room temperature, and if we have only one RF channel, then by choosing a rotating frame which rotates with the RF frequency of the channel, we can derive the following terms for the total Hamiltonian [42, 2, 3, 4]:

$$H_{\text{free}}=\sum_{i=1}^{n}(\omega_{0,i}-\omega_{\text{rf}})\sigma_{z}^{(i)}+\sum_{i<j}J_{ij}\sigma_{z}^{(i)}\sigma_{z}^{(j)},$$

(1)

$$H_{\text{ctrl}}=\omega_{1}(t)(\cos(\phi(t))\sum_{i=1}^{n}\sigma_{x}^{(i)}+\sin(\phi(t))\sum_{i=1}^{n}\sigma_{y}^{(i)}),$$

(2)

$$\gamma_{i}B_{1}(t)=\omega_{1}(t),\gamma_{i}B_{0}=\omega_{0,i},$$

(3)

where $B_{0}$ is the static magnetic field, and $B_{1}(t)$ and $\phi(t)$ represent the amplitude and the phase of the applied RF field, respectively. $\gamma_{i}$ is the gyromagnetic ratio for each nucleus in the system. Because $B_{1}(t)$ is significantly smaller than $B_{0}$, and the system is homo-nuclear we used the approximation $\gamma_{i}B_{1}(t)=\omega_{1}(t)$ for any $i$. The $H_{\text{ctrl}}$ and the first term in $H_{\text{free}}$ are due to the Zeeman interaction and the second term in $H_{\text{free}}$ represents the J-coupling between different nuclei [3].

To implement the desired quantum logic gates, we must determine $B_{1}(t)$ and $\phi(t)$. As a common technique in the GRAPE algorithm, these pulses are approximated as constant within $N$ discrete time steps. Within each step, the amplitude and phase remain constant, allowing us to compute the system’s overall operation by multiplying the operations from each time step. Since the Hamiltonian is constant within each step, we can readily calculate the dynamics for that period. Consequently, the total operation resulting from the pulse sequence is obtained by the product of the dynamics across all steps [43]. In this algorithm, the derivative of fidelity with respect to control parameters is computed. By iteratively updating these parameters and moving in the direction of the gradient, we can converge on the optimal solution [15]. To simplify the learning process and reduce the number of control parameters, we used only phases to develop control pulses while keeping the amplitude constant. As we will see (and discussed in [40, 41]), this constraint does not significantly limit us in achieving acceptable fidelities, and we can reach high fidelities by only modulating the phase. To test the stability of this approach, after calculating the phase-modulated pulse with constant amplitude, we used it as the initial state for the GRAPE algorithm, by adding the amplitudes as an additional control parameters. The final result was not significantly different from the initial state, indicating that these pulses approximately satisfy the condition of zero gradient Euclidean norm with respect to phase elements, even after additional degrees of freedom related to amplitudes are added to the optimization problem.

As previously discussed, efficiently training the target neural network requires a set of samples with high cosine similarity. One straightforward strategy involves generating a series of random pulses and computing the resulting operations they enact on the system. After calculating the cosine similarity between the randomly generated pulses in this approach, we found that the similarity was not particularly significant.
We then considered utilizing the GRAPE algorithm to develop a training set for the neural network. This time, we selected a variety of single-qubit gates at random and used the GRAPE algorithm to determine the optimal control pulses for their implementation, each with the same starting point. Additionally, we examined $16$ samples generated using the GRAPE algorithm for a specific logic gate, each with a different starting point.
A comparison between Fig.2 and Fig.3 illustrates a noticeable increase in similarity among the samples when generated using the GRAPE algorithm with the same starting point. Therefore, a critical aspect of using the GRAPE algorithm for generating the training pulses is initiating the search from the same starting point. By beginning from the same point in the GRAPE algorithm to seek pulses for the desired gates, we effectively narrowed down a specific region in the space of control parameters. This means that within this region, the pulses are closely related to one another.
Finally, we selected the random unitary operations and subsequently used the GRAPE algorithm, initiating from the same starting point, to generate the control pulses necessary for their implementation. After creating 17,000 samples, we trained a feed-forward neural network [44] to establish the mapping function between the the overall operation applied to the system and control pulses. To implement the layers of the neural network, we utilized the architecture depicted in Fig. 5.

To evaluate the performance of the developed neural network, we employed various numerical illustrations. Firstly, We began by uniformly selecting points on the sphere (Using the cosine inverse approach) to determine the corresponding rotation axis of the unitary operations in Bloch sphere. We also uniformly selected the angle of the rotation around that axis. This process was repeated 15,000 times. Finally, these unitary matrices were fed into the trained network. The fidelity was then calculated using the standard definition:

$$F(\rho,\sigma)=Tr({\rho\sigma}).$$

(4)

Next, we plotted the histogram of the fidelity, as illustrated in Fig.6, which demonstrates the perfect quality of the results.

In Table.1, you’ll find information on the generated pulses. As illustrated, this method is significantly faster than the standard GRAPE approach, which typically takes at least 15 seconds. Consequently, this method is approximately three orders of magnitude faster, and can be integrated as part of the compiler in quantum computer architectures.

As a second illustration of the network’s performance, we conducted tests on the following gates using the network, where $H$ represents the Hadamard gate:

$$U_{x}(\theta)=He^{-i\theta\sigma_{x}^{(1)}},U_{y}(\theta)=He^{-i\theta\sigma_{y}^{(1)}},U_{z}(\theta)=He^{-i\theta\sigma_{z}^{(1)}}.$$

(5)

The gate fidelities corresponding to unitary transformations given in Eq.5 are plotted against rotation angle $\theta$ in Fig.7.

Finally, we examine the fidelity results of the pulses generated by the network for unitary transformations corresponding to different axes and different angles as given by:

$$U(\theta,\alpha)=e^{-i\theta(\cos(\alpha)\sigma_{x}^{(1)}+\sin(\alpha)\sigma_{y}^{(1)})}.$$

(6)

The gate fidelities corresponding to the unitary transformation given in Eq.6 is plotted against $\theta$ and $\alpha$ in Fig.8 and Fig.9.

The mean and standard deviation of the fidelites of implementing the unitary transformation given in Eq.6 with our network are 95% and 8%, respectively.

To ensure that the neural network will perform properly in real experiments, we experimentally implemented the generated pulses for quantum logic gates of Eq.6 on a real benchtop NMR system. In NMR spectroscopy, the average value of the magnetization in the direction prependicular to $B_{0}$, is measured and subsequently subjected to a Fourier transformation.It has been shown that within the frequency domain, the observed peaks correspond proportionally to specific elements of the system’s density matrix [45, 2, 3]. Our NMR system is a $1Tesla$ benchtop spectrometer with $C_{2}F_{3}I$ molecule, with fluorine nuclei serving as qubits. At $1Tesla$, we observed the following constants of the experiment:

	$\displaystyle\omega_{1}-\omega_{rf}=-1375\,\text{Hz},$		(7)
	$\displaystyle\omega_{2}-\omega_{rf}=56\,\text{Hz},$
	$\displaystyle\omega_{3}-\omega_{rf}=-1035\,\text{Hz}$

	$\displaystyle\omega_{rf}=40\,\text{MHz},$		(8)
	$\displaystyle J_{1,2}=-67\,\text{Hz},$
	$\displaystyle J_{1,3}=28\,\text{Hz},$
	$\displaystyle J_{2,3}=38\,\text{Hz}$

where the term $\omega_{i}$ represents the Larmor frequency for the $i^{th}$ nucleus. In Fig.10, the output spectrum of the simple square shape pulse applied to the thermal state is depicted. In the context of NMR spectroscopy for a 3-qubit system with fully coupled nuclei, one would expect to observe 12 distinct peaks [45, 2, 3]. This phenomenon is clearly demonstrated in the output spectrum. To demonstrate the precision of the neural network, we generated pulses by using various values of $\alpha$ and $\theta=\frac{\pi}{4}$ for the operations of the form Eq.6. Fig.13 represents the simulation results of the spectrum around qubit-1 after applying gates presented in Eq.6 for different $\alpha$ values on pseudo-pure state. Fig.13 illustrates the theoretical behavior of both real and imaginary components of the NMR spectrum. In Fig.12 the experimental result for these pulses are presented. Comparing the experimental results with the simulations for various values, one can observe the consistency of the phase behavior between the real and imaginary parts. Now, we perform integration on the spectrum of real and imaginary functions in Fig.12 and Fig.13, and subsequently define the corresponding phase of the output signal as follows:

$$Im=\int_{f1}^{f2}im(f)\,df,Re=\int_{f1}^{f2}re(f)\,df,$$

(9)

$$Phase=\tan^{-1}(\frac{Im}{Re}),$$

(10)

where $f_{1}$ to $f_{2}$ represents the frequency range in which the Larmor frequency for the desired spin exclusively falls within this range—excluding other spins—as we aim to calculate the intensity related to this spin, and ‘im’ and ‘re’ correspond to the imaginary and real parts of the spectrum in Fig.12 and 13. By calculating the Phase in Eq.10, for different values of $\alpha$ in Fig.12 and 13, we can obtain the results shown in Fig.14. This similarity in the simulation and experimental outcomes suggests that the model is sufficiently precise at this scale, and also the Neural Network Generated-pulses perform admirably.

In the procedure of tomography in an NMR setting, we integrate the Fourier transform of the output. The relationship between the real and imaginary parts is crucial for recognizing the prepared state and applied quantum logic gates [45, 2, 3]. This test demonstrates the power of neural network-generated pulses in designing relevant quantum logic gates.

For the theoretical discussion, consider applying the gate in Eq.6 to the state $\ket{000}$:

	$\displaystyle e^{-i\frac{\pi}{4}(\cos(\alpha)\sigma_{x}^{(1)}+\sin(\alpha)\sigma_{y}^{(1)})}\ket{000}=$		(11)
	$\displaystyle\frac{1}{\sqrt{2}}(\ket{000}+(-i\cos(\alpha)+\sin(\alpha))\ket{100})$

By calculating the output signal of NMR, we observe that the integral of the output Fourier transform of the signal for the aforementioned state (For an equivalent state relative to the pseudo-pure state.), around the frequency related to qubit one is [45, 2, 3]:

	$\displaystyle Im=-\cos(\alpha),Re=\sin(\alpha)\rightarrow$		(12)
	$\displaystyle Phase=\tan^{-1}(-\cot(\alpha))$

Now, it is clear why there is a linear relationship in Fig. 14 between the defined phase in Eq.10 and $\alpha$ in Eq. 6.

In summary, we demonstrated the feasibility of extending optimal control theory for implementing arbitrary quantum logic gates through neural networks and illustrated the employment of the GRAPE algorithm to train the network. We demonstrated that using this approach, the cosine similarity between GRAPE-generated pulses used as training samples increases when the GRAPE algorithm is initiated from the same point, facilitating the learning process. After implementing the network, we tested it using numerical simulations, thereby verifying the success of the method. The feasibility of directly implementing arbitrary single-qubit gates without decomposing them into basic gates, helps achieve logical gates with higher fidelity and fewer steps. This approach significantly enhances circuit depth, which is particularly crucial in the NISQ era. When combined with the GRAPE-generated pulse for the CNOT gate, it creates an effective set of universal gates capable of implementing more complex algorithms in today’s quantum computers. Moreover, the approximate real-time generation of control pulses for arbitrary operations allows the network to be integrated into the compiler within quantum computer architecture. Finally, we experimentally validated the effectiveness of the output control pulses generated by the developed neural network. For future research, it is important to expand this concept to arbitrary two-qubit gates (i.e., Controlled-U gates) and explore the feasibility of designing a neural network for a larger number of qubits. This is crucial because, as the number of qubits increases, the system’s dimensionality grows exponentially. This growth could hinder our ability to compute such large-dimensional matrices, rendering the calculation of overall dynamics infeasible.