Quantifying Quantum Coherence Using Machine Learning Methods

Abstract

Quantum coherence is a crucial resource in numerous quantum processing tasks. The robustness of coherence provides an operational measure of quantum coherence, which can be calculated for various states using semidefinite programming. However, this method depends on convex optimization and can be time-intensive, especially as the dimensionality of the space increases. In this study, we employ machine learning techniques to quantify quantum coherence, focusing on the robustness of coherence. By leveraging artificial neural networks, we developed and trained models for systems with different dimensionalities. Testing on data samples shows that our approach substantially reduces computation time while maintaining strong generalizability.

1. Introduction

Quantum coherence refers to the possibility of creating a superposition of a set of orthogonally distinguishable states in quantum physics and quantum information science [1]. It is an indispensable element in multi-particle interference, entanglement, and other phenomena, and can also be regarded as a quantum resource in some quantum processing tasks [2,3,4]. Especially in the field of thermodynamics, the theory of coherent quantum resources has brought new enlightenment and has energy value in terms of thermodynamic work [5,6]. Recent studies have shown that quantum coherence can serve as a useful resource for improving the performance of some thermal machines [7,8,9] and the charging power of quantum batteries [10,11].

There are many types of quantum coherence measures like coherence measure based on entanglement and discord [12,13,14], intrinsic randomness of coherence [15], the basis independent set coherence [16], coherence distillation and cost [3,17], measures based on Fisher information [18], and relative entropy of coherence [19,20]. The robustness of coherence [21,22], serving as an operational measure of quantum coherence, is not only feasible to observe experimentally but also numerically assessable through semidefinite programming. In practice, fast and accurate calculations of coherence values are crucial. However, this is a challenge because this computational process relies on convex optimization techniques, and the time required can increase significantly as the state dimension of the processing increases.

Machine learning methods have been recently brought to the field of quantum physics and quantum information to address problems such as quantum-state tomography and estimation [23,24], quantum error correction code [25], wave function reconstruction [26]. In particular, it is found that machine learning methods are useful in entanglement detection [27,28,29,30] and quantification [31]. Meanwhile, machine learning methods are adopted in the classification of Einstein–Podolsky–Rosen (EPR) steering [32]. Recently, Zhang et al. presented a semisupervised support vector machine method on EPR steering that showed a significant improvement in accuracy and labor-saving [33]. Methods of artificial neural network to quantify two-qubit steerability have also been proposed [34]. Therefore, machine learning plays a positive role in the detection and quantification of quantum information resources.

Inspired by these recent research progresses, in this work we combine machine learning methods with the quantification of quantum coherence measured by the robustness of coherence. We first obtain the dataset of labeled quantum states by using the semidefinite programming. Then, we train artificial neural networks (ANNs) for two-qubit, qubit-qutrit and three-qubit systems. ANNs are computational models inspired by biological neural systems. In this work, we utilize a backpropagation (BP) neural network, a type of multi-layer feedforward network trained via the error backpropagation algorithm, which is among the most widely used neural network models [35]. This method can straightforwardly be extended to arbitrary dimensional quantum systems. By applying the trained model to test samples and an example of non-Markovian dynamics of coherence, we show the trained models have strong generalization ability.

This paper is organized as follows. We briefly review the ROC from the viewpoint of quantum resource theory, the feedforward neural network and the methods for data preprocessing in Section 2. We describe our results of training the model for two-qubit, qubit-qutrit and three-qubit systems in Section 3. A conclusion is given in Section 4.

2. Materials and Methods

In this section, we first briefly introduce the concepts of quantum coherence and the quantifier concerned in Section 2.1. Then, we briefly review the machine learning method we adopted, i.e., the feedforward neural network in Section 2.2. Finally, we describe the methods for data processing in Section 2.3.

2.1. The Robustness of Coherence

Let us analyze the quantifier of quantum coherence within the framework of quantum resource theory (QRT). A QRT consists of three main components: free states, resource states, and free or restricted operations. Mathematically, a quantum state is represented by a normalized Hermitian operator $\rho$ that satisfies ${\rho }^{†}=\rho$ and $\mathrm{tr}\left\{\rho \right\}=1$. In a specific basis, it is simply a Hermitian matrix with a trace of one. A quantum operation is defined as a linear, completely positive map from the set of density operators to itself [36]. A consistent QRT ensures that resource states cannot be generated from free states using free operations.

We adhere to the framework of quantum coherence QRT as described by Baumgratz et al. [2]. In this framework, the free states are those with diagonal density matrices in a specific basis, represented as

$$\delta =\sum _i{\delta }_i|i\rangle \langle i|,$$

(1)

where $\{|i\rangle \}$ is a fixed reference basis in a finite-dimensional Hilbert space and ${\delta }_i$ forms a probability distribution. In the context of quantum coherence QRT, these free states are referred to as incoherent states, and the set of incoherent states is denoted by $\mathcal{I}$. The resource states, known as coherent states, are those that cannot be expressed in this form.

In order to characterize the set of free operations, we recall that quantum operations are specified by a set of Kraus operators $\left\{K_n\right\}$ satisfying ${\sum }_n{K}_n^{†}{K}_n=I$. For a quantum operation, the corresponding Kraus representation is not unique. The free operations, called incoherent operations, are thus defined as those operations for which there exist a Kraus representation $\left\{K_n\right\}$ such that $K_n\rho K_n^{†}/\mathrm{tr}\left(K_n\rho K_n^{†}\right)\in \mathcal{I}$ for all n and all $\rho \in \mathcal{I}$. The restriction guarantees that in an overall quantum operation $\rho \mapsto {\sum }_n{K}_n\rho K_n^{†}$, quantum coherence cannot be generated from incoherent input states, even if someone has access to individual measurement outcomes n, not even probabilistically.

Now, let us look at the robustness quantifier for quantum coherence, i.e., the robustness of coherence (ROC). Note that quantum coherence can be treated as a useful resource in certain quantum tasks, and the robustness of a resource can be defined within a general resource theory [37]. Let $\mathcal{D}\left({\mathbb{C}}^d\right)$ be the convex set of density operators acting on a d-dimensional Hilbert space. The ROC of a quantum state $\rho \in \mathcal{D}\left({\mathbb{C}}^d\right)$ is defined as

$${\mathcal{C}}_{\mathcal{R}}\left(\rho \right)=\underset{\tau \in \mathcal{D}\left({\mathbb{C}}^d\right)}{min}\left\{s\ge 0\left|{\displaystyle \frac{\rho +s\tau }{1+s}}=:\delta \in \mathcal{I}\right.\right\}.$$

(2)

Intuitively, given a quantum state $\rho$, one can mix it with another state $\tau$ according to the weight s. The resulting normalized state may be either coherent or not. Hence, the ROC of $\rho$ can be viewed as the minimum weight of another state $\tau$, when their convex mixture yields an incoherent state $\delta$. For an incoherent state $\rho$ which already belongs to $\mathcal{I}$, it is no need to be mixed with another state to achieve incoherence. Hence, the ROC for an incoherent state is zero. Moreover, in the Equation (2), $\tau$ can be a coherent state as well as an incoherent state, otherwise, the minimum s would diverge for any state $\rho$ that possesses nonzero coherence, for the non-diagonal elements of the state matrix cannot be eliminated.

In order to show the property of computability for the ROC, one must first realize that any state $\rho$ can be reduced to an incoherent one through a dephasing operation $\Delta \left(\rho \right)={\sum }_i|i\rangle \langle i|\rho |i\rangle \langle i|$ in the reference basis $\{|i\rangle \}$. Then, one must introduce the notion of coherence witnesses. A coherence witness is an observable represented by a Hermitian operator W satisfying $\Delta \left(W\right)\ge 0$ if and only if $\mathrm{tr}\left(\delta W\right)=\mathrm{tr}(\delta \Delta (W\left)\right)\ge 0$ for all incoherent state $\delta \in \mathcal{I}$. Observing $\mathrm{tr}\left(\rho W\right)<0$ indicates that the state $\rho$ has coherence. Then, the evaluation of ${\mathcal{C}}_{\mathcal{R}}$ can be recast [22] as a semidefinite program (SDP) [38]:

$$\begin{array}{ccc}\hfill max& & -\mathrm{tr}\left(W\rho \right),\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& & W\le I,\hfill \\ & & \Delta \left(W\right)\ge 0.\hfill \end{array}$$

(3)

Using the open-source MATLAB-based CVX modeling system for convex optimization [39,40], Piani et al. [21] developed MATLAB code to assess the robustness of asymmetry and coherence in arbitrary quantum states. Notably, linking the robustness of coherence (ROC) with witness operators makes ROC especially useful for detecting coherence effects in energy transport phenomena within light-harvesting systems [41,42].

2.2. The Feedforward Neural Network

The feedforward neural network (FNN) is the earliest and simplest form of artificial neural networks (ANNs) introduced [43]. In this network structure, data flow in a single direction, from the input layer to the output layer. There are also other types of ANNs, such as recurrent neural networks, wherein connections between nodes may form loops. We adopt an FNN in the present paper. If using the backpropagation algorithm [44] to train the FNN, one also refers to this network model as BP neural network.

In Figure 1, we depict the structure of the BP neural network. It comprises five layers: one input layer, three hidden layers, and one output layer. The number of hidden layers and the number of nodes in each hidden layer may be adjusted based on the specific problem and the performance of the predictions. The BP neural network can address both classification and regression problems. Since the network needs to output the ROC value of a quantum state, which is a continuous number, there is only one node in the output layer. The number of nodes in the input layer is related to the dimensionality of the density matrix and should equal the number of variables contained in the matrix elements. Specifically, if $\rho \in \mathcal{D}\left({\mathbb{C}}^d\right)$, the number of nodes in the input layer will be $d^2$ if we restrict to real entries, because it must match the number of matrix elements. While designing the number of nodes for the input and output layers is straightforward, designing the hidden layers is more complex [45]. There are several heuristics useful for designing the hidden layers, and the actual structure should ultimately be determined by its performance.

Let us explore how backpropagation (BP) is utilized for training feedforward neural networks (FNNs). Each element in our dataset consists of matrix elements arranged in a vector $\mathit{x}$ and the corresponding ROC value y. If the dataset $\{({\mathit{x}}_1,y_1),({\mathit{x}}_2,y_2),\cdots ,({\mathit{x}}_N,y_N)\}$ with N samples is collected, we have to randomly split it into two sets: one for training the model and the other one for testing the performance. The overall network operates through $g\left(\mathit{x}\right)=f^L\left(W^L{f}^{L-1}(W^{L-1}\cdots f^1\left(W^1\mathit{x}\right)\cdots )\right),$ where L represents the total number of layers, while $W^l=\left(w_{jk}^l\right)$ denotes the weight matrix connecting layer $l-1$ to layer l, with $w_{jk}^l$ indicating the weight between the k-th node in layer $l-1$ and the j-th node in layer l. The function $f^l$ denotes the activation function at layer l, which is crucial for capturing nonlinear properties in the problem. In this study, we employ the ReLU activation function $\mathrm{ReLU}\left(x\right)=max(0,x).$

The initialization of weights is typically randomized. Training the network is essential for adjusting these weights to minimize the average discrepancy between the network’s prediction $g\left(\mathit{x}\right)$ and the actual target y. This discrepancy is measured using a loss function. We choose the mean-squared error (MSE) as the loss function:

$$\mathrm{MSE}={\displaystyle \frac{1}{N}}\sum _{i=1}^N{(g\left({\mathit{x}}_i\right)-y_i)}^2,$$

(4)

because for small errors, MSE can be advantageous due to its sensitivity to error magnitudes [46].

Updating the weight $w_{ij}^l$ involves assessing how changes in $w_{ij}^l$ impact the loss function E. If $\partial E/\partial w_{ij}^l>0$, increasing $w_{ij}^l$ increases E, so we subtract a suitable value $\Delta w_{ij}^l$. To facilitate this, we employ a fixed learning rate $\eta >0$. Similar reasoning applies when $\partial E/\partial w_{ij}^l<0$. This technique is known as gradient descent, where $\Delta w_{ij}^l=-\eta (\partial E/\partial w_{ij}^l).$

A common issue in neural networks is overfitting, where the model performs exceptionally well on the training data but poorly on new, unseen data. To detect overfitting, a portion of the training data is reserved as a validation set. Monitoring the accuracy on this set ensures the model comprehends the data rather than simply memorizing it. Training halts once accuracy on the validation data plateaus, a strategy known as early stopping.

Post-training, evaluating the model on a test set is crucial. In addition to MSE, we use $R^2$ as an evaluation metric:

$$R^2=1-{\displaystyle \frac{{\sum }_i{(y_i-g\left({\mathit{x}}_i\right))}^2}{{\sum }_i{(y_i-\overline{y})}^2}},$$

(5)

where $\overline{y}$ represents the mean of the target values in the test set. The $R^2$ value ranges from 0 to 1, with higher values signifying a closer fit between the predictions and the actual values.

2.3. Data Preparation

We begin by preparing datasets for training BP neural networks. Initially, we focus on two-qubit systems, where each Hilbert space dimension is 2, resulting in $4\times 4$ matrices for states $\rho$. Drawing inspiration from [47], we generate $6\times {10}^6$ density matrices, each containing 16 matrix elements. These matrices are reshaped into vectors ${\mathit{x}}_i$ with 16 entries, using real entries for simplicity. For each density matrix ${\rho }_i$, we compute its corresponding ROC and label it as the target $y_i$. This completes the dataset collection, where each data point is represented as $\{{\mathit{x}}_i,y_i\}$ with 17 entries.

Next, we extend our discussion to qubit-qutrit and three-qubit systems, where the Hilbert space dimensions are 6 and 8, respectively. States in these systems are described by $6\times 6$ and $8\times 8$ matrices. Consequently, each dataset entry consists of 37 and 65 entries, respectively, consisting of ROC values and matrix elements. We partition the entire dataset into training and test sets, reserving $20\%$ for testing and utilizing the remaining $80\%$ for training. The training set is further divided, with $20\%$ allocated to a validation set and the remaining $80\%$ serving as the training subset.

Our neural networks are implemented using TensorFlow [48], featuring 3 hidden layers. We adopt ReLU as the activation function and Adam as the gradient descent optimizer. The learning rate is set to $0.001$, and the batch size is 64. To mitigate overfitting, we employ an early stopping strategy. Notably, achieving an optimal network structure often requires hyperparameter optimization [49]. In this study, we systematically adjust parameters such as layer count, node density per layer, and learning rates based on observed performance to finalize our network configurations. The machine learning code and data generation scripts used in this paper can be found in [50].

3. Results

Now, let us train the model for $\rho$ for the two-qubit systems. The numbers of nodes in the three hidden layers are all set to 64 and the number of trainable parameters for this network is 9473. The loss functions (MSE) are plotted against epoch for both the training set and validation set in Figure 2. It can be shown in Figure 2 that both errors decrease dramatically in the first few epochs. As we continue the training, the MSE for the training set keeps decreasing, while the MSE for the validation set has some ups and downs. This indicates the possibility of overfitting. Now, we use the early stopping strategy that in case the loss function does not improve over 10 epochs, the training stops. Eventually, the training process finishes at an epoch of about 38.

In order to see the generalization ability of the trained model, we apply it to the test set. The MSE for the test set is $2.3644\times {10}^{-4}$. These error values are small and imply the trained network has a good generalization on the test set. In order to see this more clearly, we plot the predicted ROC versus the actual ROC for the test set in Figure 3. The horizontal and vertical coordinates of each hollow circle in the figure represent the actual values and predicted values of ROC, respectively, by the trained model for one sample in the test set. The red line indicates the case that the predicted ROC equals the actual ROC. The closer these dots are to the line, the more accurate the predicted ROC is. Moreover, we also calculate the $R^2=0.9994$, which is high and close to 1. We can see that the trained model has a strong generalization ability on the test set.

As an application, we now apply the trained model to the coherence dynamics for a two-qubit system under a non-Markovian environment. This system is composed of two parts, each one consisting of a two-level system interacting with a reservoir [51]. The Hamiltonian of the system is

$$H=\hslash {\omega }_0{\sigma }_{+}{\sigma }_{-}+\sum _k\left[\hslash {\omega }_k{b}_k^{†}{b}_k+\left(g_k{\sigma }_{+}{b}_k+g_k^{*}{\sigma }_{-}{b}_k^{†}\right)\right],$$

(6)

where ${\omega }_0$ is the transition frequency, ${\sigma }_{\pm }$ is the system raising and lowering operators for the qubit, $b_k^{†}$ ($b_k$) is the creation (annihilation) operator, and $g_k$ is the coupling of the mode k with frequency ${\omega }_k$. If the initial state is the Werner-like state

$$\rho =r|\Phi \rangle \langle \Phi |+{\displaystyle \frac{1-r}{4}}I$$

(7)

with r the purity and the coupling are non-Markovian with spectral density

$$J\left(\omega \right)={\displaystyle \frac{1}{2\pi }}{\displaystyle \frac{\Gamma {\lambda }^2}{{({\omega }_0-\omega )}^2+{\lambda }^2}},$$

(8)

where $\Gamma$ is the system–reservoir coupling constant and $\lambda$ is the spectral width of the coupling. We obtain the density matrix of the qubits system according to Ref. [51] and calculate the ROC using both the SDP method and the FNN. In Figure 4, we plot the predicted and the actual ROC as a function of the dimensionless quantity $\Gamma t$. It can be seen that our trained model has a good generalization. Moreover, it is worth noting that the time required to process a single state using the FNN is approximately ${10}^{-6}$ s, whereas using the SDP method directly takes around ${10}^{-1}$ s. This means our method is roughly ${10}^5$ times faster than the SDP approach.

Next, we discuss larger dimension states of the qubit-qutrit and the three-qubit systems. The Hilbert space dimensions of these two systems are 6 and 8, respectively. In these cases, the performance decreases when using the same structure of neural network model as in previous two-qubit system. Therefore, we increase the number of nodes in each hidden layer to 256. As a result, the number of trainable parameters will increase. For example, in three-qubit case, we have a total of 148,481 trainable parameters. Apart from this change, methods of data preparation and training processes of the neural network are the same with those of the two-qubit system. As shown in Figure 5, the trainings for the qubit-qutrit system and the three-qubit system accomplish within training epochs of 38 and 72, respectively. The MSE of the qubit-qutrit system is $8.5269\times {10}^{-4}$. For the three-qubit system, the MSE is $0.0035$, which is relatively larger than the qubit-qutrit system. This is because using the same neural network structure for more complex problems may result in slightly inferior outcomes. The predicted ROC curve overlaps extremely well with the actual ROC curve, as shown in Figure 6, with $R^2$ values reaching $0.9988$ and $0.9688$, respectively. Therefore, we can conclude that in the case of the qubit-qutrit and the three-qubit systems, the trained neural network method exhibit strong generalization ability.

4. Conclusions

In this study, we have applied machine learning to address the quantification of quantum coherence. Utilizing the SDP program, we computed the ROC and created labeled datasets for two-qubit, qubit-qutrit, and three-qubit systems, subsequently training FNNs for each. This method can be easily extended to other quantum systems with varying dimensions. We demonstrated the robust generalization capabilities of the FNNs by testing them on sample datasets. Additionally, we predicted the quantum coherence dynamics in a two-qubit system within a non-Markovian environment and compared these predictions with those obtained using the CVX method. It turns out that this approach is very accurate and time-saving. Our results highlight the considerable potential of machine learning techniques in the quantification of quantum coherence.