QuantumCircuitBornMachine
gradient based training of Quantum Circuit Born Machine
view repo
Quantum circuit Born machines are generative models which represent the probability distribution of classical dataset as quantum pure states. Computational complexity considerations of the quantum sampling problem suggest that the quantum circuits exhibit stronger expressibility compared to classical neural networks. One can efficiently draw samples from the quantum circuits via projective measurements on qubits. However, similar to the leading implicit generative models in deep learning, such as the generative adversarial networks, the quantum circuits cannot provide the likelihood of the generated samples, which poses a challenge to the training. We devise an efficient gradient-based learning algorithm for the quantum circuit Born machine by minimizing the kerneled maximum mean discrepancy loss. We simulated generative modeling of the Bars-and-Stripes dataset and Gaussian mixture distributions using deep quantum circuits. Our experiments show the importance of circuit depth and gradient-based optimization algorithm. The proposed learning algorithm is runnable on near-term quantum device and can exhibit quantum advantages for generative modeling.
READ FULL TEXT VIEW PDFgradient based training of Quantum Circuit Born Machine
Unsupervised generative modeling is at the forefront of deep learning research Goodfellow et al. (2016)
. Unlike the extremely successful discriminative tasks such as supervised classification and regression, the goal of generative modeling is to model the probability distribution of observed data and generate new samples accordingly. Generative modeling finds wide applications in computer vision
Zhu et al. , speech synthesis Van Den Oord et al. , as well as chemical design Gómez-Bombarelli et al. (2016). And it is believed to be a crucial component towards artificial general intelligence. However, generative modeling is more challenging than discriminative tasks since it requires one to efficiently represent, learn and sample from high-dimensional probability distributions Goodfellow et al. (2016).In parallel to the rapid development of deep learning, there is heated ongoing research to fabricate intermediate scale quantum circuits Preskill (2018); Knight (2017); *Google2018
. Quantum hardware may show greater potential than their classical counterparts in generative tasks. Multiple schemes have been proposed to boost the performance of classical generative models using quantum devices. For example, quantum Boltzmann machines
Amin et al. ; Khoshaman et al. ; Benedetti et al. (2017) generalize the energy function of classical Boltzmann machines Ackley et al. (1985) to quantum Hamiltonian for possible stronger representational power and faster training. A concern which may prevent the quantum Boltzmann machine from surpassing its classical counterpart is the limited connectivity on the actual quantum hardware Dumoulin et al. (2014). LABEL:Gao2017 introduces a quantum generalization of the probabilistic graphical model Koller and Friedman (2009), which can be exponentially more powerful than its classical counterpart and has exponential speedup in training and inference at least for some instances under reasonable assumptions in computational complexity theory.Another class of arguably simpler quantum generative models named Born machines Han et al. ; Cheng et al. ; Benedetti et al. directly exploit the inherent probabilistic interpretation of quantum wavefunctions Born (1926). Born machines represent probability distribution using quantum pure state instead of the thermal distribution like the Boltzmann machines Ackley et al. (1985). Therefore, Born machines can directly generate samples via projective measurement on the qubits, in contrast to the slow mixing Gibbs sampling approach. Moreover, computational complexity considerations on quantum sampling problems suggest that a quantum circuit can produce probability distribution that is #P-hard Fortnow and Rogers (1999); Aaronson and Arkhipov (2011); Lund et al. (2017), which is infeasible to simulate efficiently using classical algorithms. The same reasoning underlines the current efforts towards "quantum supremacy" experiments by sampling outcomes of random quantum circuits Boixo et al. . LABEL:Han2017
performed a classical simulation of the Born machine using the matrix product state representation of the quantum state. It will be even more promising to realize the Born machines using quantum circuits since one can at least efficiently prepare some of the tensor networks on a quantum computer
Huggins et al. . Recently, Ref. Benedetti et al. demonstrated experimental realization of the Born machine on a four qubits shallow quantum circuit trained by gradient-free optimization of measurement histograms.To further scale up the quantum circuit Born machine (QCBM) to larger number of qubits and circuit depth, one needs to devise an appropriate objective function for the generative tasks without explicit reference to the model probability. Unlike the tensor network simulation Han et al. , QCBM belongs to implicit generative models since one does not have access to the wavefunction of an actual quantum circuit. Thus, QCBM can be used as a simulator to generate samples without access to their likelihoods, which is similar to the notable generative adversarial networks (GAN) Goodfellow et al. (2014); Goodfellow . Compared to generative models with explicit likelihoods such as the Boltzmann machines Hinton and Salakhutdinov (2006), normalizing flows Oord et al. ; Dinh et al. ; Kingma et al. ; Rezende and Mohamed ; Papamakarios et al. (2017)
, and variational autoencoders
Kingma and Welling ; Rezende et al. , the implicit generative models can be more expressive due to less restrictions in their network structures. On the other hand, having no direct access to the output probability also poses challenge to the scalable training of quantum circuits.Moreover, one also needs better learning algorithm than the gradient-free optimization scheme Benedetti et al. , especially given the noisy realization of current quantum circuits. Similarly, scalability of the optimization scheme is also a crucial concern in deep learning, in which deep neural networks can even reach billions of parameters Simonyan and Zisserman
. In the history of machine learning, gradient-free algorithms were employed to optimize small-scale neural networks
Minsky and Papert (1969). However, they failed to scale up to a larger number of parameters. It is the back-propagation algorithm Rumelhart et al. (1986)which can efficiently compute the gradient of the neural network output with respect to the network parameters enables scalable training of deep neural nets. It is thus highly demanded to have scalable quantum algorithms for estimating gradients on actual quantum circuits.
Recently, gradient-based learning of quantum circuits has been devised for quantum control Li et al. (2017) and discriminative tasks Farhi and Neven ; Mitarai et al. . Although they are still less efficient compared to the back-propagation algorithm for neural networks, these unbiased gradient algorithms can already greatly accelerate the quantum circuit learning. Unfortunately, direct application of these gradient algorithms Li et al. (2017); Farhi and Neven ; Mitarai et al. to QCBM training is still non-trivial since the output of the generative model is genuinely bit strings which follow high-dimensional probability distributions. In fact, it is even an ongoing research topic in deep learning to perform differentiable learning of implicit generative model with discrete outputs Goodfellow ; Li and Turner .
In this paper, we develop an efficient gradient-based learning algorithm to train the QCBM. In what follows, we first present a practical quantum-classical hybrid algorithm to train the quantum circuit as a generative model in Sec. II, thus realize a Born machine. Then we apply the algorithm on Bars-and-Stripes and double Gaussian peaks datasets in Sec. III. We show that the training is robust to moderate sampling noise, and is scalable in circuit depth. Increasing the circuit depth significantly improves the representational power for generative tasks. Finally, we conclude and discuss caveats and future research directions about the QCBM in Sec. IV.
Given a dataset containing independent and identically distributed (i.i.d.) samples from a target distribution , we set up a QCBM to generate samples close to the unknown target distribution. As shown in Fig. 1, the QCBM takes the product state as an input and evolves it to a final state by a sequence of unitary gates. Then we can measure this output state on computation basis to obtain a sample of bits . The goal of the training is to let the model probability distribution approach to .
We employ a classical-quantum hybrid feedback loop as the training strategy. The setup is similar to the Quantum Approximate Optimization Algorithm (QAOA) Farhi et al. (a, b); Otterbach et al. and the Variational Quantum Eigensolver (VQE) Peruzzo et al. (2014); O’Malley et al. (2016); Kandala et al. (2017)
. By constructing the circuits and performing measurements repeatedly we collect a batch of samples from the QCBM. Then we introduce two-sample test as a measure of distance between generated samples and training set, which is used as our differentiable loss. Using a classical optimizer which takes the gradient information of the loss function, we can push the generated sample distribution towards the target distribution.
The overall circuit layout is similar to the IBM variational quantum eigensolver Kandala et al. (2017), where one interweaves single qubit rotation layers and entangler layers shown in Fig. 1. The rotation layers are parameterized by rotation angles , where the layer index runs from to , with the maximum depth of the circuit. is a combination of qubit index and arbitrary rotation gate index, where the arbitrary rotation gate has the form with . The total number of parameters in this QCBM is , with the number of qubits ^{1}^{1}1The number of parameters here is not here because the leading and trailing gates can be omitted without affecting the output probability distribution..
We employ CNOT gates with no learnable parameters for the entangle layers to induce correlations between qubits. In light of experimental constraints on the connectivity of the circuits, we make the connection of the entangle layers to be sparse by requiring its topology as a tree (i.e. the simplest connected graph). From the classical probabilistic graphical model’s perspective Koller and Friedman (2009), the tree graph that captures information content of the dataset most efficiently is Chow-Liu tree Chow and Liu (1968). Since controlled unitary gates have a close relation with classical probability graphical models Low et al. (2014), we employ the same Chow-Liu tree as the topology of CNOT gates. To construct the Chow-Liu tree we first compute mutual information between all pairs of the bits for samples in the training set as weights, and then construct the maximum spanning tree using, for example, the Kruskal’s algorithm. The assignment of the control bit and the target bit on a bond is random, since the Chow-Liu algorithm treated directed and undirected graphs the same. In the case where this connection structure is not directly supported by the hardware, a combination of SWAP gates and CNOT gates can be used to efficiently simulate the required structure Zulehner et al. .
The performance of entangle layers constructed in this procedure is better than most random connections with the same number of gates. This data-driven quantum circuit architecture design scheme respects the information content of the classical dataset easier and may alleviate issues of vanishing gradients for large-scale applications Huggins et al. .
Viewing the QCBM as an implicit generative model Mohamed and Lakshminarayanan , we train it by employing the kernel two-sample test Anderson et al. (1994). The idea is to compare the distance in the kernel feature space on the samples drawn from the target and the model distributions. We refer the following loss function as the squared maximum mean discrepancy (MMD) Gretton et al. (2007, 2012)
(1) |
The summation in the first line runs over the whole Hilbert space. The expectation values in the second line are for the corresponding probability distributions. The function maps to a high-dimensional reproducing kernel Hilbert space Hofmann et al. (2008). However, as common in the kernel tricks, by defining a kernel function one can avoid working in the high-dimensional feature space. We employ a mixture of Gaussians kernel to reveal differences between the two distributions under various scales. Here, is the bandwidth parameter which controls the width of the Gaussian kernel. The sample
can either be a bit string (vector) or an integer (scalar) depending on the representation. When
is a bit string, stands for the -norm in the vector space. The MMD loss with Gaussian kernels asymptotically approaches zero if and only if the output distribution matches the target distribution exactly Gretton et al. (2007, 2012). The same loss function was used to train the generative moment matching networks (GMMN)
Li et al. (a); Dziugaite et al. ; Li et al. (b).To learn the QCBM as a generative model, we compute gradient of the loss function Eq. (1) with respect to the circuit parameters
(2) | |||||
Here, and are output probabilities of QCBM under circuit parameters , where is the -th unit vector in parameter space (i.e. , with other angles unchanged). In contrast to the finite difference methods like simultaneous perturbation stochastic approximation (SPSA) Spall (1998), Eq. (2
) is an unbiased estimator of the exact gradient. Its detailed derivations is in Appendix
A.In order to estimate the gradient [Eq. (2)] on an actual quantum circuit, one can repeatedly send rotation and entangle pulses to the device according to the circuit parameters , and then perform projective measurements on the computational basis to collect binary samples . While for , one can simply take a batch of data from the training dataset ^{2}^{2}2For the small dataset employed in our numerical experiment, we can afford to average over the whole training dataset.. The sampling noise in the estimated gradient is controlled by the number of measurements
, denoted as the batch size. After one has obtained a sufficiently accurate gradient, one can use a classical optimizer to update the circuit parameters similar to the stochastic gradient descent training of deep neural nets.
Parameter learning of quantum circuits is adaptive in the sense that the implementation of quantum gates can even be non-ideal. One can obtain gradients with high accuracy as long as the parametrized single qubits rotation gates are precise, which is relatively easier to achieve experimentally. The optimization scheme is independent of the detailed form of non-parametrized entangle gates. Thus, the CNOT gate in the setup can be replaced by any gate which can generate desired quantum entanglements.
It is instructive to compare the training of the QCBM to that of classical implicit generative models such as GAN Goodfellow et al. (2014); Goodfellow and GMMN Li et al. (a); Dziugaite et al. ; Li et al. (b)
. Classically, one does not have access to the likelihood either. The gradient is thus obtained via the chain rule
, which then does not apply for discrete data. On the other hand, the unbiased gradient estimator of the QCBM takes advantage of the known structure of the unitary evolution and the MMD loss (see Appendix A), despite that the probability of the outcome is unknown. In this sense, quantum circuits exhibit a clear quantum advantage over classical neural nets since they fill the gap of differentiable learning of implicit generative models of discrete data.We carry out numerical experiments by simulating the learning of QCBM on a classical computer. These experiments reveal advantages of gradient based optimization over gradient-free optimization, and demonstrate stronger expressibility of deep circuits over shallow ones. The code can be found at the Github repository git
We first train a QCBM on the Bars-and-Stripes dataset MacKay (2003); Han et al. ; Benedetti et al. , which is a prototypical image dataset consists of vertical bars and horizontal stripes. On a grid of , the dataset contains 14 valid configurations. We model the pixels with a quantum circuit of qubits. The Chow-Liu tree for this dataset is shown in Fig. 2 (a). Bonds are either row-wise or column-wise since correlations of pixels sharing the same row/column index are dominant in this dataset. The bandwidths used in Gaussian kernels of MMD loss are .
For circuit depth , our gradient-based training is able to reduce the MMD loss efficiently. The loss function for different iteration steps is shown in Fig. 3(a). We first perform L-BFGS-B Byrd et al. (1995) optimization (black dashed line) using the exact gradient computed via the wavefunction () to test the expressibility of the quantum circuit. A loss of can be achieved, showing that the circuit is quite expressive in terms of the two-sample test.
In practice, one has to perform projective measurements on the qubits to collect statistics of the gradient since the wavefunction is inaccessible. This situation is similar to the mini-batch estimate of the gradient in deep learning Goodfellow et al. (2016). As is well known in the deep learning applications Goodfellow et al. (2016), the L-BFGS-B algorithm is not noise tolerant. Thus, it is unsuitable for quantum circuit learning in realistic situation. One needs to employ an alternate optimizer which is robust to the sampling noise to train the quantum circuit with noisy gradient estimator.
We employ the stochastic gradient optimizer Adam Kingma and Ba with the learning rate . The sampling noise in the gradients can be controlled by tuning the batch size of the measurements. The solid lines in Fig. 3 (a) show that as the sample size increases, the final MMD loss reduces systematically. The scatters in the inset confirmed that the model probability of learned quantum circuit and the target probability aligns better with lower MMD loss.
To visualize the quality of the samples, we generated a few samples from the QCBM trained under different measurement batch size in Fig. 4. Here, we define a valid rate as a measure of generation quality. The valid rate increases as the batch size increases. However, even with a moderate number of measurement one can achieve a valid rate . Here, we should mention that the best valid rate of layer circuit is achieved by L-BFGS-B optimizer with , which is .
To highlight the importance of using a gradient-based optimizer, we compare our approach to the covariance matrix adaptation evolution strategy (CMA-ES) Hansen (2006); Rios and Sahinidis (2013), a state-of-the-art gradient-free stochastic optimizer. The input of CMA-ES is the scalar loss function measured on the circuit instead of the vector gradient information. The CMA-ES optimizer is able to optimize non-smooth non-convex loss functions efficiently Rios and Sahinidis (2013), thus in general performs better than other gradient-free methods such as the SPSA Spall (1998) in training noisy quantum circuits. We have confirmed this in our simulation.
In the absence of sampling noise in Fig. 3 (b), we do observe that the CMA-ES optimizer is able to achieve similar performance as the Adam optimizer after steps of optimization with a population size of . The total number of generated samples is , which is comparable to the Adam training in Fig. 3 (a) ^{3}^{3}3Notice for this circuit of depth that having parameters, we need to make measurements in a gradient estimation..
However, the performance of CMA-ES deteriorates significantly once taking sampling noise into consideration, as shown for and in Fig. 3 (b). A possible explanation is that in each step of CMA-ES, its evolution strategy chooses the direction to go by inspecting the center of top instances. This process can be understood as an effective finite difference gradient estimation base on the losses of its population. However, extracting gradient information from noisy losses is difficult, even one has plenty of them.
Another advantage of using gradient-based learning is the efficiency comparing with gradient-free methods, which gets particularly significant when circuits get deeper and the number of parameters increases. In the following, we address the necessity of using deep circuits.
Fig. 5 (a) shows the MMD loss as a function of L-BFGS-B training steps for different circuit depth. One obtains lower loss for deeper quantum circuit after optimization steps. Fig. 5 (b) shows the Kullback-Leibler (KL) divergence Kullback and Leibler (1951) calculated using the circuit parameters in (a) at different training steps. Note that this quantity is inaccessible for large-scale problems since one has no access to the target nor the output probability. We compute the KL divergence for the toy model to demonstrate that the MMD loss is a good surrogate for practical training. The result indeed shows a consistency between MMD loss and KL divergence. And it also supports the observation that deep circuits have stronger representational power. Similar to deep neural networks, deep circuits can achieve better performance also due to that one is less prone to be trapped in a poor local minima with larger amount of parameters Choromanska et al. (2015).
Another advantage of the QCBM over traditional deep neural networks is that its training not suffer from gradient vanishing/exploding problem as the circuit goes deeper. Gradient vanishing/exploding is a common problem for a traditional deep neural network He et al. (2016)
which originates from multiplications of a long chain of matrices in the back-propagation algorithm. Training of the deep quantum circuits naturally circumvented this problem by due to the unitary property of the time evolution. Similar idea was exploited in constructing classical recurrent neural networks with unitary building blocks
Jing et al. . More numerical simulation and analytical explanations can be found in Appendix B.Next, we train a QCBM to model a mixture of Gaussians distribution
(3) |
Here, is an integer encoded by the qubits, with and is the number of qubits. It is different from Bars-and-Stripes dataset, in which case a sample is represented as a bit string. We choose , the centers and . The distribution is shown as the dashed line in Fig. 6(b).
In the following discussion, we use qubits and set circuit depth . Unlike the case of Bars-and-Stripes , the Gaussian mixture distribution is smooth and non-zero for all basis state. Here, we generate i.i.d. samples from the target distribution as the training set. Its Chow-Liu tree is shown in Fig. 2(b). In this graph, we see the main contributions of mutual information are from bits near the big end (most significant bits labeled by small indices). This is because the bit near the little end only determines the local translation of the probability on data axis. But for a smooth probability distribution, the value of the little end is nearly independent from values of the rest bits. For example, the value of the big-end -th bit being / corresponds to the global left/right peak in Fig. 6 (b). While the probability for the little end being corresponds to
being even/odd.
We use mixture of three Gaussian kernels with bandwidths . captures the local difference in distribution, and , which has the same scale as , which captures the overall differences in the probability distribution.
Fig. 6 (a) shows the MMD loss as a function of the Adam optimization steps, with a sample size . After training steps, the MMD loss decreased from to . To see whether this low MMD loss represents a good generative model, we then generate samples from the QCBM and plot its binned histogram in Fig. 6 (b). We see an excellent match between the histogram (green bars) and the exact probability distribution (black dashed curve). Thus, we conclude that MMD loss with Adam optimizer can also learn a smooth probability distributions over the qubit index of a QCBM. Here, we acknowledge that the unbinned histogram appears more spiky, partly due to the MMD loss does not capture the local variation of the probability distribution. Better circuit architecture design for representing continuous distribution may help alleviate this problem.
We presented a practical gradient-based learning scheme to train quantum circuit Born machine as a generative model. The key component of the learning algorithm is to measure the gradient of the MMD two-sample test loss function Eq. (2) on a quantum computer unbiasedly and efficiently. Besides possessing stronger representation power, the QCBM does not suffer from the gradient vanishing/exploding problem as circuit depth increases compared to the classical deep neural networks. While compared to other quantum generative models Amin et al. ; Gao et al. , the quantum circuit Born machine has fewer restrictions on hardware and circuit design, while both the training and sampling can be efficiently carried out.
A recent work Mcclean et al.
pointed out that the quantum circuit also faces gradient vanishing problem as the number of qubits increases. They found that the variance of gradient amplitudes decreases exponentially as the number of qubits increases in a random quantum circuit. However, it is reasonable to believe that with better circuit structure design and parametrization strategy, such Sec.
II.1 and Ref. Huggins et al., or using shared weights such as done in the convolutional neural networks
Goodfellow et al. (2016), the gradient vanishing problem can be alleviated. How gradient vanishing really affects gradient-based training in a large-scale QCBM needs further systematic investigation.Our simulation of the quantum circuits Born machine is limited to a small number of qubits, thus the training set contains all patterns and we are pushing the circuits towards the memorization limit. In future applications, one shall focus on the generalization ability of the quantum circuits. In those cases, the structure and depth of a quantum circuit provide means of regularization since they can be design to express inductive bias in the natural distributions. In terms of the learning, the randomness in the stochastic gradient is also in favor of the generalization Choromanska et al. (2015).
Besides the two-sample test loss employed in this paper, one can explore alternative training schemes, e.g. adversarial training Goodfellow et al. (2014). Alternatively, learning of the kernel function used in Eq. (1) may also improve the generation quality Li et al. (b)
. Finally, differentiable learning of the QCBM may be used for solving combinatorial optimization problems and structure learning tasks, where the outputs are encoded in discrete bit strings.
Simulations of quantum circuits were mainly performed using the ProjectQ library Steiger et al. ; Häner et al. (2018). We thank Alejandro Perdomo-Ortiz, Miles Stoudenmire, Damian Steiger, Xun Gao and Pan Zhang for helpful discussions. The authors are supported by the National Natural Science Foundation of China under the Grant No. 11774398 and research program of the Chinese Academy of Sciences under Grant No. XDPB0803.
In the following, we derive Eq. (2) in the main text, starting from the partial derivative of Eq. (1)
(4) |
The partial derivative on the right-hand side of this equation can be unbiasedly computed using the approach of Li et al. (2017); Mitarai et al. . For a circuit containing a unitary gate parametrized as with (e.g. can be Pauli operators, CNOT or SWAP), the gradient of the expected value of an observable with respect to the parameter reads
(5) |
where represents expectation values of observables with respect to the output quantum wave function generated by the same circuit with circuit parameter . Note Eq. (5) is an unbiased estimate of the gradient in contrast to the finite difference approachs which are sensitive to noise of the quantum circuit.
Since the quantum circuit Born machine employs the same parametrization, we identify as the observable and apply Eq. (5) to the output probability of the circuit
(6) |
where , with the -th unit vector in parameter space. Substituting Eq. (6) into Eq. (4) we have
(7) |
Using the symmetric condition of the kernel , we arrive at Eq. (2) in the main text. This gradient algorithm for QCBM scales as with the depth of the circuit, which is less efficient compared to the linear scaling back-propagation algorithm for classical neural networks. It is still unknown whether one can reach similar scaling on a quantum computer since the back-propagation algorithm requires cached intermediate results in the forward evaluation pass. We have checked the correctness of the gradient estimator Eq. (2) against numerical finite difference.
To gain a better understanding of what kind of losses for a quantum circuit can be easily differentiated, we generalize the above result by considering an arbitrary function , with a sequence of bit strings as its arguments. Let’s define the following expectation of this function
(8) |
Here, is the offset angles applied to circuit parameters, which means the probability distributions of generated samples is . Writing out the above expectation explicitly, we have
(9) |
where index runs from to . Its partial derivative with respect to is
(10) |
Again, using Eq. (6), we have
(11) |
If is symmetric, becomes a V-statistic v. Mises (1947), then Eq. (11) can be further simplified to
(12) |
which contains only two terms. This result can be readily verified by calculating the gradient of MMD loss, noticing the expectation of a kernel function is a V-statistic of degree . By repeatedly applying Eq. (11), we will be able to obtain higher order gradients.
The KL divergence Kullback and Leibler (1951) reads
(13) |
Its gradient is
(14) |
where the term cannot be transformed to a sampling problem on the quantum circuit. Since minimizing the negative log-likelihood is equivalent to minimizing the KL-divergence, it faces the same problem.
In this appendix, we analyze the effect of depth and sampling error to gradients. For a qubit quantum circuit of depth with random parameters used in generating the Bars-and-Stripes dataset in the main text. Histogram of MMD loss gradient values in different layers are shown in Fig. 7 (a). Distributions of gradients in different layers have no significant differences, thus deep QCBM does not suffer from vanishing or exploding gradients when the layers go deeper. This property has its physical origin in how the wave function changes when a perturbation is applied to of the quantum circuit. Suppose we have a quantum circuit that performing the following evolution,
(15) |
Introduce a perturbation to ,
(16) |
Its fidelity with respect to unperturbed wave function is
(17) |
Here, can be assumed to be random in a deep circuit. Thus we have the fidelity susceptibility You et al. (2007); Wang et al. (2015) which is independent of . Since we have , is bounded by , and is independent of the layer index.
Next, we show the error in gradient estimation will decrease systematically as the number of samples increases for MMD loss. As can be seen from the curve of variance calculated using copies of independent samples in Fig. 7
(b). In our case, to give a valid estimation of gradients, the standard error should be lower than the typical amplitude of gradients. As can be referred from Fig.
7 (a), the typical amplitude of gradient is approximately , thus the sample size should be larger than in order to give a good estimation to these gradients.