Decoding Small Surface Codes with Feedforward Neural Networks

TL;DR

This paper explores using feedforward neural networks to decode small surface codes efficiently, achieving comparable or better performance than traditional algorithms while potentially reducing decoding time for quantum error correction.

Contribution

It introduces a neural network-based decoding approach for small surface codes, demonstrating generalization and performance improvements over existing algorithms.

Findings

Neural network decoders can generalize to unseen inputs.

Neural decoders achieve similar or better accuracy than traditional algorithms.

Potential for faster decoding in hardware implementations.

Abstract

Surface codes reach high error thresholds when decoded with known algorithms, but the decoding time will likely exceed the available time budget, especially for near-term implementations. To decrease the decoding time, we reduce the decoding problem to a classification problem that a feedforward neural network can solve. We investigate quantum error correction and fault tolerance at small code distances using neural network-based decoders, demonstrating that the neural network can generalize to inputs that were not provided during training and that they can reach similar or better decoding performance compared to previous algorithms. We conclude by discussing the time required by a feedforward neural network decoder in hardware.

Figures

Tables

Table 1. Table 1: Layer sizes for the neural networks used throughout this work. The number of input nodes is determined by the number of syndromes in the quantum error correction scenario, using only X 𝑋 X (or Z 𝑍 Z ) syndrome bits for independent X 𝑋 X / Z 𝑍 Z errors, and all syndrome bits for depolarizing errors. In the fault tolerance scenario, d 𝑑 d rounds of measurement are followed by readout of the data qubits, and calculated stabiliser eigenvalues are included in the input. The output layer is restricted to two nodes for independent X 𝑋 X / Z 𝑍 Z errors, since logical X 𝑋 X / Z 𝑍 Z errors are also independent. In all other scenarios, four nodes are used to discriminate between 𝟙 ^ ^ 1 \hat{\mathbb{1}} , X ¯ ¯ 𝑋 \bar{X} , Y ¯ ¯ 𝑌 \bar{Y} , and Z ¯ ¯ 𝑍 \bar{Z} . The number of nodes in the hidden layer is determined by analysing the performance of the resulting decoder empirically.

QEC Error Models
Channel Capacity Noise
Code distance	Input nodes	Hidden nodes	Output nodes
3	4	10	2
5	12	90	2
7	24	512	2
Depolarizing Noise
3	8	128	4
5	24	660	4
7	48	256	4

Equations

$$X:\begin{array}[]{c}\ket{0}\mapsto\ket{1}\\ \ket{1}\mapsto\ket{0}\end{array},\,\,Z:\begin{array}[]{c}\ket{0}\mapsto\ket{0}\\ \ket{1}\mapsto-\ket{1}\end{array},\,\,Y:\begin{array}[]{c}\ket{0}\mapsto i\ket{1}\\ \ket{1}\mapsto-i\ket{0}\end{array}$$

$$E=S\cdot C\cdot L,$$

$$⟨H(p,y)⟩\propto -\sum _{(\vec{p},\vec{x})\in T}\vec{p}\cdot \ln (\vec{y}(\vec{x})),$$

Full text

I Introduction

Quantum computing has emerged as a solution to accelerate various calculations using systems governed by quantum mechanics. Such calculations are believed to take exponential time to perform using classical computers. Initial applications where quantum computing will be useful are simulation of quantum physics Georgescu et al. (2014), cryptanalysis Shor (1997); Monz et al. (2016) and unstructured search Grover (1997), and there is a growing set of other quantum algorithms Jordan (2016).

Simple quantum algorithms have been shown to scale better than classical algorithms Wu et al. (2011); Liu and Zhang (2015); Peruzzo et al. (2014) for small test cases, though larger computers are required to solve real-world problems. The main obstacle to scalability is that the required quantum operations (state preparations, single- and two-qubit unitary gates, and measurements) are subject to external noise, therefore quantum algorithms cannot run with perfect fidelity. This requires quantum computers to use active error correction DiCarlo et al. (2009) to achieve scalability, which in turn requires a classical co-processor to infer which corrections to make, given a stream of measurement results as input. If this co-processor is slow, performance of the quantum computer may be degraded (though recent results Chamberland et al. (2017) suggest that this may be mitigated).

The remainder of this paper is organized as follows. In Section II, we outline the relevant aspects of quantum error correction and fault tolerance. We discuss the need for a fast classical co-processor in Section III. In Section IV, we give a brief summary of existing techniques to perform decoding quickly, and follow this in Section V with the introduction of a new technique based on feedforward neural networks. We examine the accuracy of the proposed decoder in Section VI, and conclude by discussing its speed in Section VII.

II Quantum error correction

While it is often possible to decrease the amount of noise affecting a quantum operation using advanced control techniques Kaveh et al. (2010); Motzoi et al. (2009), their analog nature suggests that some imperfection will always remain. This has driven the development of algorithmic techniques to protect quantum states and computations from noise, which are called quantum error correction and fault tolerance, respectively.

Quantum error correction replaces unprotected qubit states (e.g. $\ket{0}$, $\ket{1}$) with specially encoded multi-qubit entangled states (typically called $\ket{\bar{0}}$, $\ket{\bar{1}}$), such that a random operation $E$ acting on fewer than $d$ qubits cannot transform one encoded state into another ($\bra{\bar{0}}E\ket{\bar{1}}=0$), where $d$ is called the code distance Gottesman (1997); Lidar and Brun (2013). Typically, these random operations are taken to be Pauli operators, whose names and effects on single-qubit states are given below:

[TABLE]

These operators form a convenient basis for the space of possible errors; codes which can correct these errors on a subset of qubits can correct arbitrary errors on the same subset (Lidar and Brun, 2013, Chapter 2).

Often, the encoded states are chosen to be in the mutual $+1$ eigenspace of a set of multi-qubit Pauli operators, called stabilisers, resulting in a stabiliser code. Projective measurements of the stabilisers are used by a reliable classical co-processor to determine which error has occurred, a process called decoding. The use of stabiliser codes can effectively reduce the probability of error from transmitting a qubit through a noisy channel (though logical errors can still occur, acting as $\bar{X}$, $\bar{Z}$, or $\bar{Y}$). This reduction in the probability of error is obtained when operations are perfect, however, quantum error correction is not enough on its own to guarantee that computation can be performed with a low probability of error when using noisy operations.

To suppress errors from the physical operations themselves, it is necessary to design logical operations which act directly on encoded states (i.e. without first transforming the encoded states to bare qubit states), in such a way that random errors affecting physical operations are likely to result in correctable errors with respect to the underlying code. Operations which have this property are called fault-tolerant. Fault-tolerant syndrome measurements can be applied repeatedly to correct time-dependent errors, which occur continuously as computation proceeds. There are many schemes for attaining fault tolerance, based on different families of quantum codes, and using different techniques for ensuring noise from imperfect state preparation and stabiliser measurement remains suppressable.

Each fault tolerance scheme has a threshold error rate, beneath which there exists a code in the associated code family which can suppress errors to exponential accuracy, using a polynomially-large number of qubits and operations Preskill (1998). Each code in such a family also typically has a pseudo-threshold, an error rate at which encoded operations using that specific code provide higher accuracy than is possible using bare qubits/operations. These figures of merit are used to characterize fault tolerance schemes, and are especially important when considering near-term implementations of these schemes.

One scheme which has a relatively high threshold error rate uses surface codes Kitaev (2003); Freedman and Meyer (2001); Bravyi and Kitaev (1998); Bombin and Martin-Delgado (2007), stabiliser codes whose stabilisers are supported on qubits which are adjacent on a 2D square tiling (see Figure 1).

This approach also allows the use of exclusively planar connections between qubits, and uses at most four connections between each qubit and its neighbours (see Figure 2). These features make surface codes especially attractive for near-term implementation.

To complete such an implementation and analyse its performance, it is also necessary to specify the method by which surface codes are to be decoded. Syndromes obtained by measuring surface code stabilisers have a special mathematical structure, which leads to a polynomial-time decoding algorithm. These syndromes occur at the endpoints of continuous one-dimensional chains of errors if stabiliser measurement is performed with perfect operations, and differences between consecutive syndromes occur at the endpoints of one-dimensional chains of data/measurement errors if realistically noisy operations are used (see Figure 3). If error rates are low, then the smallest error which conforms with the syndrome is likely a valid correction. To find it requires the classical co-processor to minimize the sum of the lengths of chains connecting pairs of syndrome changes, a problem known as minimum-weight perfect matching Schrijver (2003). This problem can be solved using the Blossom algorithm Edmonds (1965); Kolmogorov (2009). This algorithm produces accurate corrections for the surface code, but has a complexity which scales polynomially with respect to $d$. This is an obstacle to using the Blossom algorithm for decoding surface codes in practice, for reasons which we explain in the following section.

III Need for fast decoding

Projective measurement of the logical qubits and classical feedforward of the measurement values are key ingredients in universal fault-tolerant quantum computing. To calculate the bit which we feed forward, we need to decode. Thus, it is necessary to decode frequently during a computation.

While the decoding takes place at the classical co-processor, we could either continue running rounds of syndrome measurement or stop and wait for the decoding to be concluded. If we stop the computation, errors will build up until they become uncorrectable. This takes an amount of time which depends on the implementation in question ($\sim 10\,\mu\textrm{s}$ in current superconducting circuits, for example O’Brien et al. (2017)). On the other hand, if we continue measuring syndromes, we will build a backlog of data that produces a more difficult decoding problem in the future. The ideal case would be a decoder that decodes $d$ rounds of syndrome measurement in less time than the time needed to perform the measurements themselves. In superconducting circuits, the time for a single round of syndrome measurement is $800\textrm{ ns}$ Versluis et al. (2016).

There are many techniques that provide high performance decoding. In the following section, we summarize some of them.

IV Related work

To decrease decoding time when correcting time-dependent errors, the “overlapping recovery” method was introduced in Dennis et al. (2002). This method divides the measurement record into windows, defined as a set of $\sim d$ consecutive error correction cycles. In the overlapping recovery technique, syndromes are matched either to each other (pairwise) or to a time boundary placed immediately after the last round of syndrome measurement. At the next window, the syndromes matched to the time boundary are forwarded to the following window, in order to identify chains of errors which cross the boundary. This reduces the backlog problem mentioned earlier, by allowing the decoding problem to be solved incrementally.

To further reduce the backlog, Fowler Fowler (2015) has parallelized the Blossom algorithm, using message-passing between local processors to replace slow subroutines. This technique produces accurate corrections, resulting in a high threshold error rate, and is scalable to large code distances. However, in the near future, only small code distances will be experimentally viable, so it is likely that a heuristic approach will perform well.

One such approach is taken in Tomita and Svore (2014). In this paper, the authors have designed a heuristic-based decoder that resembles the parallelized MWPM decoding for a distance-3 Surface Code with a window of 3 error correction cycles. The simple structure of this heuristic algorithm makes it easily programmable to hardware, decreasing the decoding time. The main drawback of this algorithm is that it cannot easily be extended to higher code distances, so an alternate method is required.

Currently, machine learning techniques are being explored as possible alternate decoding techniques, independently of the need for high-speed decoding. One such technique is being used in Torlai and Melko (2016). The authors of this paper use a stochastic neural network (or Boltzmann machine) to decode stabilizer codes. They optimize the neural network to fit a dataset that includes the errors and their respective syndromes. The network then models the probability distribution of the errors in the dataset and generates prospective recovery error chains when a syndrome is input. Many networks are produced for a variety of physical error probabilities $p$, so when an error syndrome is obtained, a random recovery chain of errors is sampled from the distribution corresponding to the known value of $p$. While this method produced similar performance to MWPM decoding for simple error models, repeated sampling is required in order to produce an error that conforms with the syndrome, which takes unknown time.

To achieve high performance in bounded time, we use a simpler machine learning technique, the feed-forward neural network, which we introduce and apply to the decoding problem in the next section.

V Neural network decoder

To apply machine learning techniques to surface code decoding, we first reduce the decoding problem to a well-studied problem in machine learning; classification. Classification problems consist of a set of (generally high-dimensional) inputs, each of which is associated with a (generally low-dimensional) label. The goal is to optimize the assignment of known labels to known inputs (a process called training) so that unknown inputs can also be correctly labeled.

To reduce the decoding problem to a classification problem, we decompose an error $E$ into three multi-qubit Pauli operators:

[TABLE]

where $S$ is a stabiliser, $C$ is any unique Pauli which produces the syndrome $\vec{s}$ (also known as a pure error Poulin (2006)), and $L$ is a logical Pauli operator of the surface code. Any decoder which provides a correction $E^{\prime}=S^{\prime}\cdot C\cdot L$, in which the stabiliser in the correction is different from that in the actual error, does not lead to a logical error. This implies that $S$ can be assigned arbitrarily with no impact on decoder performance. Also, it is possible to produce a pure error by parallel table look-up, since each bit of the syndrome can be assigned a unique pure error, independently of the other bits. We call the apparatus that produces this error the simple decoder. Since pure errors can be determined quickly in this fashion, the neural network only has to identify $L$, which can take one of four values; $\hat{\mathbb{1}}$, $\bar{X}$, $\bar{Y}$, or $\bar{Z}$. These four values can be used as labels in a classification problem.

To solve this problem, we use feed-forward neural networks, which are widely regarded as the simplest machine learning technique MacKay (2003). A feed-forward neural net can be described graphically or functionally, see Figure 4. In either description, a feed-forward neural network contains a large number of free parameters, which are assigned values which minimize a given cost function. A typical cost function, which we use in this work, is the average cross-entropy:

[TABLE]

where $T$ is the training set, consisting of desired (‘target’) distributions $\vec{p}$ and input values $\vec{x}$. To minimize this function, we use stochastic gradient descent, as implemented in the Tensorflow library Abadi et al. (2015). To produce a training set, we use direct sampling at a single physical error probability, where the Blossom algorithm produces a logical error rate of $\sim 25\%$. This physical error probability is chosen so that a large variety of error syndromes can be produced while still ensuring that correction is possible. For small surface codes, it is possible to sample the entire set of possible syndromes, we limit the size of the training set to at most $10^{6}$ samples for larger codes. This training set size provides relatively fast training and high accuracy, as seen in Section VI.

In the following section, we compare the performance of our decoder to the performance of Blossom and the performance of the partial lookup table (PLUT), which contains the error syndromes and corrections from the training set, returning the most likely correction ($\hat{\mathbb{1}}$) for error syndromes that are not in the training set. The comparison in terms of performance is based on the logical error rate of each decoder for specific code distances and error models.

VI Results

In the proposed decoder, we provide the error syndrome to both the simple decoder and the neural network. As presented in Table 1, the size of the input for the neural network is equal to the number of required syndrome bits, depending on the error model, and only one hidden layer was deemed adequate for all networks. The number of nodes in the hidden layer was decided based on the performance of the neural network during training and testing.

We test the proposed decoder against Blossom and the PLUT decoder for two classes of error models, called quantum error correction (QEC) and fault tolerance (FT). Quantum error correction (QEC) error models approximate noise only on data qubits and fault tolerance (FT) error models approximate noise on gates and operations, therefore requiring multiple rounds of measurement to find all errors. The channel capacity model inserts only $X$ or only $Z$ errors with probability $p$ in the data qubits. The depolarizing model places $X$/$Y$/$Z$ errors with equal probability, $\nicefrac{{p}}{{3}}$, on the data qubits. For these error models only one cycle of error correction is required to find all errors.

In the fault tolerance scenario, the probability of an error occurring on a qubit and the probability of a measurement error is the same, therefore the minimum number of rounds of measurement is taken to be $d$. Instead of data qubit and measurement errors, the circuit noise model assumes that all operations and gates are noisy. Each single-qubit gate is followed by depolarizing noise with probability $\nicefrac{{p}}{{3}}$ and each two-qubit gate is followed by a two-bit depolarizing map where each non-$\hat{\mathbb{1}}\otimes\hat{\mathbb{1}}$ two-bit Pauli has probability $\nicefrac{{p}}{{15}}$. Preparation and measurement locations fail with probability $p$, resulting in a prepared $-1$-eigenstate or measurement error, respectively.

In our simulations more than $10^{6}$ error correction cycles were run per point and each point has a confidence interval of 99.9%. The percentage of the most frequent error syndromes that were used as training cases for the QEC error models were $100\%$ ($d=3$), $72.46\%$ ($d=5$), $2.75\%$ ($d=7$), see figure 5, and $100\%$ ($d=3$), $0.98\%$ ($d=5$), $3\times 10^{-7}\%$ ($d=7$), see figure 6, for channel capacity and depolarizing models respectively. The percentage of the most frequent error syndromes that were used as training cases for the fault tolerance error models were $30.09\%$, $0.022\%$ and $0.01\%$ for the channel capacity (see figure 7 top), the depolarizing (see figure 7 middle), and the circuit model (see figure 7 bottom), respectively. The performance of our decoder was compared to the Blossom algorithm and the PLUT decoder.

In the QEC error models, see figure 5 and figure 6, we observe a clear trend. In both error models, as the distance increases the performance of our decoder remains similar to Blossom, and becomes much better that the PLUT-based decoder. This demonstrates that the neural networks of our decoder can successfully correct error syndromes that were not included in training. At small code distances, almost all possible error syndromes were used in training, resulting in identical performance from both the PLUT and our decoder. However, going to larger distances while using a small set of error syndromes for training, leads to sub-optimal decoding by the PLUT decoder.

It is known that, for the channel capacity error model, Blossom can reach near-optimal performance, therefore it is sufficient for our decoder to reach similar performance. There are correctable errors (with weight $\leq 3$) in distance 7 that are not included in the training set and the neural network is not generalizing correctly. Therefore, the performance is slightly worse than Blossom’s. However, for the depolarizing error model, Blossom is known to misidentify $Y$ errors, since it performs the decoding for $X$ and $Z$ errors separately, treating a $Y$ error as two distinct errors. Thus, if we train our decoder to take $Y$ errors into account as weight-1 errors, the performance will be better than Blossom’s. In the depolarizing model, there are still a few weight 3 errors that are being mis-identified, however the existance of higher weight errors in the training set, that are being corrected properly, account for the sligthly better performance compared to the Blossom decoder.

In the fault tolerance scenario, see figure 7, due to the small code distance, all decoders reach a similar level of performance. Specifically, for the channel capacity and the depolarizing error model, a small amount of error syndromes was only necessary to reach Blossom’s performance. The circuit metric required more syndromes, however slightly better performance was achieved in this case as well.

It is encouraging that the neural network based decoder can achieve similar performance to Blossom. However, the main reason that such a design is proposed is to accelerate the decoding time. In the following section, we provide an estimation of the speed of the neural network based decoder in hardware, and discuss the implications for future research.

VII Discussion and conclusion

In order to accurately estimate the execution time of the proposed decoder in hardware, we take advantage of the ability to perform many operations in parallel. For example, in the simple decoder, the correction for each syndrome bit is independent of the other bits, allowing all of these corrections to be derived simultaneously. In order to determine whether to apply an $X$ to a given qubit, for example, it is then necessary to determine the parity of the number of corrections affecting the qubit. There are at most $\left\lfloor\nicefrac{{d}}{{2}}\right\rfloor$ possible corrections (this is the largest possible number of syndrome bits between an arbitrary syndrome bit and the boundary), and evaluating the parity of a set of $b$ bits requires a tree-like circuit of depth $\left\lceil\log_{2}(b)\right\rceil$ xor gates. In an FPGA (field-programmable gate array), simple operations such as xor can be evaluated in a single clock cycle, typically $2.5$–$5$ nsMehta (2012). We can also take advantage of the graphical description of neural networks (see Figure 4) to evaluate their output quickly. Firstly, the output of each neuron can be evaluated independently, so the runtime is dominated by the time needed to take an inner product between the weight vector and an intermediate state in the network. Each multiplication can be performed independently, and summation requires a logarithmic number of adders, similar to calculating parity. In a digital signal processing (DSP) slice, present in most FPGAs, simple arithmetic operations can also be carried out in a single clock cycle.

For our largest neural network, then, we require two multiplications (one for the hidden layer, and one for the output layer), 15 addition steps ($\lceil\log_{2}(32)\rceil+\lceil\log_{2}(768)\rceil$), and two evaluations of the sigmoid function, for a total of $19$ serial steps. If each of these can be carried out in a single clock cycle, the time required will be $\sim 100$ ns. This timing estimate is optimistic, since it does not account for the possibility that high-accuracy arithmetic may require additional clock cycles, or that communication between distant components of the FPGA may take longer than arithmetic operations. However, if these factors increase the execution time by a factor of $\sim 20$, the proposed decoder will still be able to decode the syndrome from three consecutive rounds of measurement if each round requires $\sim 800$ ns.

Immediate future work will focus on implementing the proposed decoder in hardware, to determine the overhead caused by communication. Once this overhead is reduced to an acceptable level, we can begin to extend the proposed decoder to the case where syndromes from a finite window are fed forward, as in Dennis et al. (2002). In addition, we can begin testing the applicability of feedforward neural networks to surface codes with larger distance, as well as to alternate codes for which existing decoders do not attain high accuracy and speed simultaneously Bombin and Martin-Delgado (2006); Landahl et al. (2011); Bombin et al. (2012).

In conclusion, feedforward neural networks provide a fast and accurate method to decode small surface codes, both for performing quantum error correction, as well as fault-tolerant operations. Given that the hardware requirements and anticipated runtime are relatively low, we expect feedfoward neural network decoders to be usable in the near term.