Question: Represent the text to find a very short summary (1-2 sentences max)!

Question: The field of deep learning has been craving for an optimization method that shows outstanding property for both optimization and generalization. We propose a method for mathematical optimization based on flows along geodesics, that is, the shortest paths between two points, with respect to the Riemannian metric induced by a non-linear function. In our method, the flows refer to Exponentially Decaying Flows (EDF), as they can be designed to converge on the local solutions exponentially. In this paper, we conduct experiments to show its high performance on optimization benchmarks (i.e., convergence properties), as well as its potential for producing good machine learning benchmarks (i.e., generalization properties). Due to recent progress in the field of machine learning, it becomes more and more important to develop and sophisticate methods of solving hard optimization problems. At the same time, in this field, such methods are additionally required to elicit decent generalization performance from statistical models. An efficient method of mathematical optimization, however, does not always produce sufficient generalization properties, since these are involved with two distinct mathematical problems; The former is to find one of the solutions which minimize a given (possibly non-convex) objective function, and the latter is to adjust parameters so that a statistical estimator achieves its best . To address such a hard issue, we introduce a new mathematical perspective on optimization, and develop a method for machine learning based on this perspective. We then empirically show its rapid convergence rate and high compatibility with deep learning techniques, as well as good statistical properties. In this field, many optimization methods have been proposed and modified so that they fit specific problems or models. One of the current standard methods is the gradient descent method. The method tends to converge slowly in general optimization problems. However, with various specific techniques, such as mini-batch training and batch normalization BID9 ), it has been found to be efficient for state-of-the-art purposes in the field of deep learning. Another class of methods that are now becoming popular and standard is adaptive methods, such as AdaGrad BID6 ) and Adam . Compared to the gradient descent method, these methods have been shown to improve convergence rates with almost the same computational cost as the gradient descent method, but are reported to in poor statistical outcomes in some cases of machine learning BID16 ).Other class of methods that have been thoroughly studied in the theory of mathematical optimization is second-order methods, such as the Newton method and the Gauss-Newton method. These methods possess great convergence properties, and in particular, have a potential to overcome plateau's problems BID5 ). Furthermore, when it comes to applications in stochastic settings, the method based on the Gauss-Newton Matrix (or Fisher information Matrix) is shown to asymptotically attain the best statistical , which is called Fisher efficiency (see BID0). Despite these attractive characteristics, the methods have not yet been spotlighted in the field of machine learning due to several severe drawbacks; They suffer from high computational cost in general and their useful properties are no longer guaranteed in practical settings (see Section 12 in BID12). One of the continuously developing second-order methods in this field, K-FAC BID1, BID7 ), successfully produced high convergence rate empirically with relatively low computational cost. However, it still requires much effort to become compatible with some deep learning techniques. In addition, it is unclear whether the method has advantages in generalization performance. In our approach, by introducing a Riemannian metric induced by non-linear functions, we constitute dynamical systems which describe motions along the shortest route from arbitrary initial points to the zeros of non-linear functions on the corresponding Riemannian manifold, that is, geodesic with respect to the Riemannian metric. One of the remarkable characteristics of our approach is that it enables us to flexibly design flows of such dynamical systems to control convergence rates. The for the flows are then applicable to mathematical optimization problems, in particular, with deep neural network (DNN) models. In this paper, after providing mathematical ground of our methods, we experimentally demonstrate their performance in various aspects, from convergence rates to statistical properties. We start by establishing some essential properties of dynamics which are effective for the analysis of non-linear equations. Let F: R N → R N be a smooth function and J be the Jacobian with variable w ∈ R N, that is, J = ∂F/∂w. In this section, we deal with the well-posed case that there exists a connected closed subset Ω ⊂ R N, where J is regular and the equation has a unique solution ξ. Therefore, the positive matrix G = J T J induces a Riemannian metric g on Ω and (Ω, g) becomes a Riemannian manifold under some appropriate conditions. Let us then consider time evolution of variable w on this manifold. Our main purpose in this section is to study the characteristics of dynamical systems in which w(t) moves on geodesics between any point in Ω and ξ with respect to the metric g. Let L be a Lagrangian given by DISPLAYFORM0 with v = dw/dt (also written asẇ). The Euler-Lagrange equation for L is then expressed as dp dt DISPLAYFORM1 with momentum vector p = Gv. If the boundary condition at two points in Ω, w(t 0) = w 0, w(t 1) = w 1, is imposed on, a geodesic between w 0 and w 1 is obtained as the solution. In contrast, if we give an appropriate initial condition, w describes the motion along the geodesic from w 0 to w 1. In fact, the following statement holds; Theorem 2.1. Let w 0 be an arbitrary point in Ω and (w(t), p(t)) be a solution of equation FORMULA1 with the following initial condition; DISPLAYFORM2 Then w satisfies F w(t) = (1 − t)F w 0, for t ∈. In particular, w(t) passes through the point which is a solution of non-linear equation DISPLAYFORM3 We briefly describe the outline of the proof for the statement above. Throughout this paper, we regard functions of w as those of t in the trivial way; for instance, F (t) = F (w(t)). Note that p can be expressed as p = J T dF/dt. Then using the Beltrami identity for with the initial condition above leads to the equation DISPLAYFORM4 where F 0 = F. Thus, a closed form expression is obtained as DISPLAYFORM5 which gives F = 0 as asserted in Theorem 2.1. Now we take a different expression that the coefficient (1 − t) in is replaced by a different monotonically decreasing function, that is, DISPLAYFORM6 where ρ denotes a monotonically decreasing smooth function from (t 0, t 1) onto. Then, we give the following differential equation whose solution is of the closed form; DISPLAYFORM7 A motion described by this differential equation differs from the one that is described by, but these two motions are along the same geodesic. Theorem 2.2. Let w 0 ∈ Ω be an arbitrary point. The differential equation DISPLAYFORM8 with an initial condition w 0 = w(t 0) has a unique solution that satisfies F (w(t 1)) = 0. Furthermore, the orbit under flow f defined by f (w 0, t) = w(t) coincides with that of the geodesic equation.Note that since equation FORMULA8 is equivalent to equation FORMULA7, the orbit is invariant under coordinate transformations. With respect to the choice of ρ, the end point t 1 can be set as ∞ under some appropriate conditions and Theorem 2.2 still holds in the sense that DISPLAYFORM9 In particular, if we set ρ(t) = e −t, then χ(t) = −1 and F can be represented as F (t) = e −t F 0, so that the convergence rate of F is exponential. Definition 2.3. Let w be a solution of the differential equation DISPLAYFORM10 with an initial condition w 0 = w(t 0). The flow f (w 0, t) = w(t) is called an exponentially decaying flow (EDF) of non-linear equation F (w) = 0.For the end of this section, we present a connection between EDF and the classical Newton method. If we apply the Euler method to the differential equation with step size t, the corresponding iteration step can be written as DISPLAYFORM11 which recovers the Newton method with step size η i = t · χ(τ i). Consider smooth functions ϕ: DISPLAYFORM0 In this section, we develop a method based on EDF for a mathematical optimization problem of the form DISPLAYFORM1 In this section, the area Ω ⊂ R N is supposed to be a compact subset where there exists no stationary point except for a minima. DISPLAYFORM2 An example of such problems is least squares one in which L is given by DISPLAYFORM3 In this case, F = ϕ. In particular, if M = N and a minimal value of loss function L = L • ϕ is zero, the optimization problem is equivalent to solving non-linear equation F (w) = 0.For optimization problems, we set up a standard equation that the gradient of loss function is zero, that is, ∇ L(w) = 0. Note that the gradient can be expressed as ∇ L(w) = J T ϕ F (w) with Jacobian J ϕ = ∂ϕ/∂w. Applying Theorem 2.2, we obtain the differential equation DISPLAYFORM4 where H is the Hessian of loss function L with respect to w. Since second order differentiation is typically computationally heavy, we seek other equations which possess almost the same property as especially in terms of asymptotic behavior. Let us decompose momentum Hẇ as DISPLAYFORM5 where J F denotes the Jacobian of F, and G is a symmetric matrix defined by DISPLAYFORM6 with Hessian matrix H L of L with respect to ϕ. We then consider the following equation instead of FORMULA0; DISPLAYFORM7 This equation no longer describes the motion along the geodesic related to in general. However, if M = N and J ϕ is invertible, then w moves on another geodesic with respect to a different metric DISPLAYFORM8 In addition, if ρ(t) = e −t, F converges exponentially, which implies that ∇ L = J ϕ F also converges exponentially in as well as in FORMULA0. In general cases, if a condition that DISPLAYFORM9 is satisfied, then F converges to 0. This shows that in the neighborhood of solution ξ of equation ∇ L = 0, the momentum Gẇ sufficiently approximates Hẇ by. Definition 3.1. The flow given by DISPLAYFORM10 is referred to EDF of type H and written as EDF-H. Similarly, the flow given by DISPLAYFORM11 is referred to EDF of type G and written as EDF-G. Like second order methods, in EDF-based methods, matrix inversion has to be carried out, which requires expensive computational cost, particularly in large systems. Moreover, we often encounter rank deficient matrices in optimization problems. To deal with rank deficiency, in general, we need pseudo-inverse matrices which are more computationally heavy. Therefore, instead of the inverse of matrix A = G, H, for fixed v ∈ R M, we consider a projection which maps r = arg min DISPLAYFORM0 One of the basic methods to construct such a projection for indefinite symmetric systems is the minimum residual method BID13 ), which requires only the matrix multiplication. Therefore, for numerical computations, we use the following differential equation approximated by the k-th order Krylov subspace; DISPLAYFORM1 k is a hyperparameter that interpolates between the gradient method and the method based on or. In fact, in the case that k = 1, equation FORMULA1 has the form DISPLAYFORM2 which reduces to a kind of gradient methods, but the coefficient c conveys information about G or H unlike the standard gradient methods. Next, similar to the Levenberg-Marquardt algorithm, we modify equation FORMULA0 by adding a damping factor to G in order that the method becomes more stable. So, we set DISPLAYFORM3 where λ is a continuous positive function of t. Then, we take the same approximation as FORMULA1 with A = G+λI. The damping factor λ plays several important roles in solving practical problems. First, it has solutions well-behaved near singularities. Even in the case that G is not invertible, equation FORMULA1 can be defined and solved unlike. If we choose λ such that it approaches to 0 as rapidly as the gradient in, the asymptotic behavior of FORMULA1 is almost the same as that of FORMULA0. Particularly, in the case that χ = −1, we set λ = a J T ϕ F b with a, b > 0, so that the convergence rate of stays exponential. Second, the damping factor makes the method compatible with stochastic approaches such as mini-batch training, in deep learning models. Since the orbit of FORMULA1 is affected by the gradient due to the damping factor λ, the method based on this equation could take advantage of stochastic approaches as other gradient methods do. (For implementation of the algorithm, see Appendix A.) Finally, to accelerate the EDF-based methods, it is sometimes effective to change equation FORMULA0 into a second-order differential equation, particularly in the case in which the approximation method with k is applied. Specifically, we take the equation DISPLAYFORM4 where κ is a real-valued function of t. The convergence properties of the methods are controlled by the following differential equation; DISPLAYFORM5 There are two ways of determining κ. The first one is to set κ = α with constant α (W1), which leads to a similar scheme to the momentum gradient decent method. The other one is to set κ(t) = αt −1 (W2). In this setting, the equation can be discretized in a similar way as described in BID15, which is analogous to the Nesterov's acceleration scheme. In this section, we present how optimization problems are set up in the field of deep learning. Let x = {x j} n−1 j=0 and y = {y j} n−1 j=0 denote training datasets of input and output, respectively, where n is the size of dataset. Let d x and d y be dimensions of input data and output data, respectively. We write ϕ nn for neural networks with parameters w ∈ R N, and define ϕ by the direct sum of vectors {ϕ j} given by ϕ j (w) = ϕ nn (x j, w), that is, ϕ = ⊕ϕ j. Note that M = n × d y in this case. Then finding a minima of a given loss function is proposed as a standard optimization problem to train networks. For the image classification tasks, there are two typical cases of setting loss functions. In the first case, the loss is set as. As already mentioned, in this case, F = ϕ and H L = I. In the second case, the loss is given by cross entropy with softmax function, that is, DISPLAYFORM0 where θ denotes the softmax function and θ j = θ(ϕ j). In this case, F is expressed by the direct sum such that F = ⊕F j with DISPLAYFORM1 where s j denotes a sum of all elements in vector y j for each j. Note that if each y j is given as a probability vector, then s j = 1. Moreover, H L is expressed as H L = ⊕H j with DISPLAYFORM2 where ⊗ denotes the outer product. In both cases, the loss functions take the minimum value 0 if and only if F = 0. In this study, we conducted following three groups of experiments; First, we examined optimization performance of the EDF-based methods on a data-fitting problem with a simple convolutional neural network model. Second, we tested both optimization and generalization performance in standard settings of classification tasks in which we employed residual network models and CIFAR-10/100 datasets. Third, we incorporated some techniques of data augmentation and regularization in the training into our experiment as we would like to measure effectiveness of our methods in more practical settings. The primary purpose of the experiments in this paper is not to pursue the state-of-the-art performance, but to explore how the statistical pertain to those of optimization when the loss functions are minimized. Therefore, we tuned hyperparameters of each method in accordance with the optimization benchmark. It should be noted that the conjecture concerning non-convex optimization problems in the field of deep learning BID2, BID4 ) is still an open problem (studied for linear cases in BID3, BID10). Hence, for experiments in this paper, we do not discuss whether each optimization method actually reaches to a global solution. We evaluated convergence performance of EDF-based methods (type G and type H) on a data-fitting problem of CIFAR-10, that is, full-batch training in the context of deep learning. The model we employed in these experiments was the convolutional neural network that consisted of two convolution filters with rectified linear units and max pooling layers, followed by two fully connected layers. For EDF-based methods, the step size was fixed to 1.0, and no damping factors were used. In addition, the acceleration technique derived from W2 of was adapted, since W2 achieved better performance than W1. A similar experiment with a different type of second-order methods was conducted in BID14.First, we examined change in convergence performance of EDF-G depending on hyperparameter k, the order of Krylov subspace. The are illustrated in the left-hand side of FIG0. The presented trend is consistent with the theoretical fact that k interpolates between the gradient method (for small k) and the method based on dynamics (for large k). In other words, when k is small, the method is similar to a gradient method, which converges slow, but as k becomes larger, the method leads to better approximation of the inverse matrix, which gives a rapidly decaying flow. Next, we compared EDF-G (k = 1, 30) with EDF-H and other standard optimizers in deep learning: gradient descent methods with Polyaks momentum scheme (Momentum) and Nesterov's acceleration scheme (NAG), and Adam. The step sizes for Momentum, NAG, and Adam were fixed to 0.01, 0.001, and 0.001, respectively. The right-hand side of FIG0 shows that both EDF-based methods made the loss decrease more rapidly than other standard optimizers. Even when EDF-based methods were reduced to the gradient methods at k = 1, EDF-G outperformed standard optimizers. The figure also presents the difference between EDF-G and EDF-H. While their convergence rates around extremes were almost the same, the overall convergence rates of EDF-G were better than that of EDF-H.As has been found, second-order-methods on full-batch training converge to the solution within a few iterations. However, with such a training, the quality of generalization becomes worse compared to the time when stochastic approach with a mini-batch of small size is taken. Like other secondorder-methods, EDF also suffers from a negative impact of full-batch training on generalization performance, though setting the hyperparameter k small makes EDF be compatible with stochastic approaches and take their advantages (see Appendix B). In the following experiments, we compared both optimization and generalization performance of EDF-G with other methods, momentum stochastic gradient decent method (MSGD) and Adam on classification tasks for CIFAR-10/100. The experiments were conducted, employing residual network models with batch normalization (Resnet-56 for CIFAR-10 and Resnet-110 for CIFAR-100), and working with a mini-batch of size 250.For CIFAR-100, during pre-investigation of the dataset, we found that 9 pairs of data, each of which has the same image but different labels, contaminated the neural network and might have had a non-negligible influence on both optimization and generalization performance (See Appendix C). Therefore, in our experiments on CIFAR-100, we excluded them from the training dataset and used the rest of the data (size = 49982).At the end of each epoch, we computed training loss in the following manner. First, the loss was defined as FORMULA1 where n is the total number of data. Second, to calculate the statistics for batch normalization in the loss, as described in BID9, we adopted so-called "inference mode" in which moving averages of mean and variance over mini-batches are used for batch-normalization. For EDF, we tested the case k = 1 and k = 2, with the damping factor set as a = b = 1. The momentum coefficient was fixed to α = 0.9 for the W1 acceleration (see 25).For each of the tasks, we ran tests on 10 different learning rates; for EDF between 0.1 and 2.0, for Momentum SGD between 0.1 and 10.0, for Adam between 0.0001 and 0.1. We then chose the one with the best convergence performance for each optimizer. For EDF with W2, to obtain stability in convergence, the learning rate was set to 0.2 times that of the initial values at the end of the 20-th epoch. Such a change in learning rate in the middle of optimization did not bring advantages to either optimization or generalization performances for other methods including EDF with W1 (see Appendix D).The are presented in Figures 2 and 3. As shown in the figures, with respect to the optimization performance, EDF reached an optimal solution with smaller error at higher convergence rate than Adam and Momentum SGD, even when k = 1, 2. Moreover, EDF overall attained better generalization performance than other methods. For classification tasks, generalization performance often improves by adopting several techniques, such as data augmentation and regularization. In this group of experiments, employing the data augmentation based on random horizontal flip and shift and the L 2 regularization, we conducted comparisons between EDF and other methods that are similar to those in the previous sections. When adopting these techniques, rate decay scheme has as large impact on optimization performance as learning rate itself. Because effectiveness of each rate decay scheme much depends on optimization methods, it is almost impossible to find the best scheme that is applicable to all the methods. For this reason, for MSGD and Adam, as initial learning rates, we chose one of the standard rates for MSGD and Adam, 0.1 and 0.001, respectively, and at the ends of the 100-th, 140-th, 180-th epochs, reset the rates to 0.1 times the rates at the moment. For EDF, we ran tests on two different rates 0.5 and 0.75, the optimal rates found in the experiments of Section 6.2, and reset to 0.2 times those of the initial values, only at the end of the 100-th epoch, in order to demonstrate performance of the EDF more clearly. Among the obtained with EDF, we chose the ones with the best optimization performance. The of the comparison is presented in Figures 4 and 5. As can be seen, we found a condition in which EDF achieved better performance than other methods on optimization while achieving sufficient levels of generalization. Obtaining good statistical from limited available data is a critical goal in machine learning. To reach this goal, while developing an effective model is an essential approach, eliciting the best performance from the fixed model through optimization is important as well. In our study, to examine the performance of our optimization methods, Exponentially Decaying Flows (EDF) based methods, we explored their generalization properties pertaining to of optimization. Our experiments showed that EDF-based methods are more likely to achieve optimal solutions which generalize the test data well than other standard optimizers are. Therefore, EDF-based methods are considered to be optimization methods that have a high potential in their application to various tasks, and thus, are worthwhile to be sophisticated through future studies. In terms of computation of the EDF-based methods with GPU, the Jacobian-vector-product can be carried out at almost the same cost as the gradient of loss function. In fact, multiplying a vector by Jacobian and its transposed matrix (written as R-op and L-op, respectively) are implemented in combination with gradients of scholar functions. For the psuedo-code for update scheme of the EDF-G with L/R-op, refer to Algorithm 1, and Algorithm 2 in particular case that k = 1.Algorithm 1: Update scheme for EDF-G with non-preconditioned MINRES Input: FIG3 shows the of experiments using EDF for simple examples that compare a full-batch training with stochastic trainings. In this example, the convolutional network similar to that used in Section 6.1 was employed on MNIST. The curve labeled as "EDF F" depicts the of Full-batch training per step, and those labeled as "EDF S" illustrate the of stochastic trainings per epoch with a mini-batch of size 500. DISPLAYFORM0 Let us divide the dataset {x, y} = {x j, y j} n−1 j=0 into distinct subsets of size p such that DISPLAYFORM0 Then, gradients and Jacobian-vector-multiplications are calculated as DISPLAYFORM1 where ϕ (i) and F (i) are the subcomponents of ϕ and F, respectively, corresponding to the decomposition above. Thus, for a fixed k, if we set p as the same size as a mini-batch, then the computational cost per step of a full-batch training becomes almost the same as that per epoch of a mini-batch training. The dataset of CIFAR-100 includes 9 pairs of irregular data, each of which has the same image but different labels. These data are enumerated in Figure 7. For instance, the 8393-rd and the 36874-th images are the same, but they have different labels, "girl (class 35)" and "baby (class 2)." Such pairs contaminate the training process. In fact, in our experiment, when the network model was optimized with the full dataset, one of the images in each 9 pairs above could not be classified correctly, which ed in stagnated training accuracy at 99.982 %. Moreover, generalization also deteriorated when irregular data were contained. For the details of these , see Figure 8. D PERFORMANCES WITH THE RATE DECAY SCHEME Figure 9 and FIG0 present the optimization and generalization performance of each optimizer when the rate decay scheme was adopted to the experiment with the same setting as in Figure 2 and Figure 3. The rate decay scheme was that the learning rate was set to 0.2 times that of the initial values at the end of the 20-th epoch.

represent the short summary for finding the corresponding scientific article (long)

Examples:
Provided: "We propose a meta-learning framework that learns a transferable policy from only weak supervision to solve synthesis tasks with different logical specifications and grammars." Match: "We study a general formulation of program synthesis called syntax-guided synthesis(SyGuS) that concerns synthesizing a program that follows a given grammar and satisfies a given logical specification. Both the logical specification and the grammar have complex structures and can vary from task to task, posing significant challenges for learning across different tasks. Furthermore, training data is often unavailable for domain specific synthesis tasks. To address these challenges, we propose a meta-learning framework that learns a transferable policy from only weak supervision. Our framework consists of three components: 1) an encoder, which embeds both the logical specification and grammar at the same time using a graph neural network; 2) a grammar adaptive policy network which enables learning a transferable policy; and 3) a reinforcement learning algorithm that jointly trains the embedding and adaptive policy. We evaluate the framework on 214 cryptographic circuit synthesis tasks. It solves 141 of them in the out-of-box solver setting, significantly outperforming a similar search-based approach but without learning, which solves only 31. The is comparable to two state-of-the-art classical synthesis engines, which solve 129 and 153 respectively. In the meta-solver setting, the framework can efficiently adapt to unseen tasks and achieves speedup ranging from 2x up to 100x. Program synthesis concerns automatically generating a program that satisfies desired functional requirements. Promising have been demonstrated by applying this approach to problems in diverse domains, such as spreadsheet data manipulation for end-users BID21, intelligent tutoring for students, and code auto-completion for programmers BID19, among many others. In a common formulation posed by BID3 called syntax-guided synthesis (SyGuS), the program synthesizer takes as input a logical formula φ and a grammar G, and produces as output a program in G that satisfies φ. In this formulation, φ constitutes a semantic specification that describes the desired functional requirements, and G is a syntactic specification that constrains the space of possible programs. The SyGuS formulation has been targeted by a variety of program synthesizers based on discrete techniques such as constraint solving BID36, enumerative search BID5, and stochastic search BID37. A key limitation of these synthesizers is that they do not bias their search towards likely programs. This in turn hinders their efficiency and limits the kinds of programs they are able to synthesize. It is well known that likely programs have predictable patterns BID23 BID1. As a , recent works have leveraged neural networks for program synthesis. However, they are limited in two aspects. First, they do not target general SyGuS tasks; more specifically:• They assume a fixed grammar (i.e., syntactic specification G) across tasks. For example, BID39 learn loop invariants for program verification, but the grammar of loop invariants is fixed across different programs to be verified. • The functional requirements (i.e., semantic specification φ) are omitted, in applications that concern identifying semantically similar programs BID34 BID0 BID2, or presumed to be input-output examples BID33 BID7 BID16 BID11 BID13 BID43 BID42 BID35.In contrast, the SyGuS formulation allows the grammar G to vary across tasks, thereby affording flexibility to enforce different syntactic requirements in each task. It also allows to specify functional requirements in a manner more general than input-output examples, by allowing the semantic specification φ to be a logical formula (e.g., f (x) = 2x instead of f = 2 ∧ f = 6). As a , the general SyGuS setting necessitates the ability to capture common patterns across different specifications and grammars. A second limitation of existing approaches is that they rely on strong supervision on the generated program BID33 BID7 BID11. However, in SyGuS tasks, ground truth programs f are not readily available; instead, a checker is provided that verifies whether f satisfies φ. In this paper, we propose a framework that is general in that it makes few assumptions on specific grammars or constraints, and has meta-learning capability that can be utilized in solving unseen tasks more efficiently. The key contributions we make are a joint graph representation of both syntactic and semantic constraints in each task that is learned by a graph neural network model; a grammar adaptive policy network that generalizes across different grammars and guides the search for the desired program; and a reinforcement learning training method that enables learning transferable representation and policy with weak supervision. We demonstrate our meta-learning framework on a challenging and practical instance of the SyGuS problem that concerns synthesizing cryptographic circuits that are provably free of side-channel attacks BID17. In our experiments, we first compare the framework in an out-of-box solver setting against a similar search-based approach and two state-of-the-art classical solvers developed in the formal methods community. Then we demonstrate its capability as a meta-solver that can efficiently adapt to unseen tasks, and compare it to the out-of-box version. The Syntax-Guided Synthesis (SyGuS) problem is to synthesize a function f that satisfies two kinds of constraints:• a syntactic constraint specified by a context-free grammar (CFG) G, and • a semantic constraint specified by a formula φ built from symbols in a theory T along with f.One example of the SyGuS problem is cryptographic circuit synthesis BID17. The goal is to synthesize a side-channel free cryptographic circuit by following the given CFG (syntactic constraint) while ensuring that the synthesized circuit is equivalent to the original circuit (semantic constraint). In this example, the grammar is designed to avoid side-channel attacks, whereas the original circuit is created only for functional correctness and thus is vulnerable to such attacks. We henceforth use this problem as an illustrative example but note that our proposed method is not limited to this specific SyGuS problem. We investigate how to efficiently synthesize the function f. Specifically, given a dataset of N tasks DISPLAYFORM0, we address the following two tasks:• learning an algorithm A θ: (φ, G) → f parameterized by θ that can find the function f i for (φ i, G i) ∈ D; • given a new task set D, adapt the above learned algorithm A θ and execute it on new tasks in D.This setting poses two difficulties in learning. First, the ground truth target function f is not readily available, making it difficult to formulate as a supervised learning problem. Second, the constraint φ is typically verified using an SAT or SMT solver, and this solver in turns expects the generated f to be complete. This means the weak supervision signal will only be given after the entire program is generated. Thus, it is natural to formulate A θ as a reinforcement learning algorithm. Since each instance (φ i, G i) ∈ D is an independent task with different syntactic and semantic constraints, the key to success is the design of such meta-learner, which we elaborate in Sec 3. This section presents our meta-solver model for solving the two problems formulated in Sec 2. We first introduce formal notation in Sec 3.1. To enable the transfer of knowledge across tasks with different syntactic and semantic constraints, we propose a representation framework in Sec 3.2 to jointly encode the two kinds of constraints. The representation needs to be general enough to encode constraints with different specifications. Lastly, we introduce the Grammar Adaptive Policy Network in Sec 3.3 that executes a program generation policy while automatically adapting to different grammars encoded in each task specification. We formally define key concepts in the SyGuS problem formulation as follows.semantic spec φ: The spec itself is a program written using some grammar. In our case, the grammar used in spec φ is different from the grammar G that specifies the syntax of the output program. However, in many practical cases the tokens (i.e., the dictionary of terminal symbols) may be shared across the input spec and the output program. DISPLAYFORM0 Here V denotes the nonterminal tokens, while Σ represents the terminal tokens. s is a special token that denotes the start of the language, and the language is generated according to the production rules defined in R. For a given non-terminal, the associated production rules can be written as α → β 1 |β 2... |β nα, where n α is the branching factor for non-terminal α ∈ V, and β i = u 1 u 2... u |βi| ∈ (V Σ) *. Each production rule α → β i ∈ R represents a way of expanding the grammar tree, by attaching nodes u 1, u 2,..., u |βi| to node α. The expansion is repeated until all the leaf nodes are terminals. Output function f: The output is a program in the language generated by G. A valid output f must satisfy both the syntactic constraints specified by G and the semantic constraints specified by φ. Different from traditional neural program synthesis tasks, where the program grammar and vocabulary is fixed, each individual task in our setting has its own form of grammar and semantic specification. Thus in the program generation phase (which we will elucidate in Sec 3.3), one cannot assume a fixed CFG and use a tree decoder like in BID26 and BID11. To enable such generalization across different grammars, the information about the CFG for each task needs to be captured in the task representation. Since the semantic spec program φ and the CFG G have rich structural information, it is natural to use graphs for their representation. Representing the programs using graphs has been successfully used in many programming language domains. In our work, we further extend the approach by BID2 with respect to the following aspects:• Instead of only representing the semantic spec program φ as a graph, we propose to jointly represent it along with the grammar G.• To allow information exchange between the two graphs, we leverage the idea of Static Single Assignment (SSA) form in compiler design. That is, the same variable (token) that may be assigned (defined) at many different places should be viewed differently, but on the other hand, these variations correspond to the same original thing. Specifically, we introduce global nodes for shared tokens and global links connecting these globally shared nodes and local nodes that (re)define corresponding tokens. The overall representation framework is described in FIG0. To construct the graph, we first build the abstract syntax tree (AST) for the semantic spec program φ, according to its own grammar (typically different from the output grammar G). To represent the grammar G, we associate each symbol in V Σ with a node representation. Furthermore, for a non-terminal α and its corresponding production rules α → β 1 |β 2... |β nα, we create additional nodes α i for each substitute β i. The purpose is to enable grammar adaptive program generation, which we elaborate in Sec 3.3. As a simplification, we merge all nodes α i representing β i that is a single terminal token into one node. Finally, the global nodes for shared tokens in Σ are created to link together the shared variable and operator nodes. This enables information exchange between the syntactic and semantics specifications. To encode the joint graph G(φ, G), we use graph neural networks to get the vector representation for each node in the graph. Specifically, for each node v ∈ G, we use the following parameterization for one step of message passing style update: DISPLAYFORM0 Lastly, {h DISPLAYFORM1 are the set of node embeddings. Here N (v) is the set of neighbor nodes of v, and e u,v denotes the type of edge that links the node u and v. We parameterize F in a way similar to GGNN BID28, i.e., F (h t, e) = σ(W e t h t) where we use different matrices W ∈ R d×d for different edge types and different propagation steps t. We sum over all the node embeddings to get the global graph embedding h(G).In addition to the node embeddings and global graph embedding, we also obtain the embedding matrix for each non-terminal node. Specifically, given node α, we will have the embedding matrix H α ∈ R nα×d, where the ith row of DISPLAYFORM2 α is the embedding of node α i that corresponds to substitution β i. This enables the grammar adaptive tree expansion in Sec 3.3. To enable the meta-solver to generalize across different tasks, both the task representation and program generation policy should be shared. We perform task conditional program generation for this purpose. Overall the generation is implemented using tree recursive generation, in the depth-first search (DFS) order. However, to handle different grammars specified in each task, we propose to use the grammar adaptive policy network. The key idea is to make the policy parameterized by decision embedding, rather than a fixed set of parameters. This mechanism is inspired by the pointer network BID44 and graph algorithm learning BID14.Specifically, suppose we are at the decision step t and try to expand the non-terminal node α t. For different tasks, the non-terminals may not be the same; furthermore, the number of ways to expand a certain non-terminal can also be different. As a , we cannot simply have a parameterized layer W h αt to calculate the logits of multinomial distribution. Rather, we use the embedding matrix H αt ∈ R nα t ×d to perform decision for this time step. This embedding matrix is obtained as described in Sec 3.2. DISPLAYFORM0 • Global graph embedding:• Embedding of production rules DISPLAYFORM0...... • Global graph embedding:• Embedding of production rules d1 -> d2 AND d2 Sampled production rule: DISPLAYFORM0 Figure 2: Generating solution using the grammar adaptive policy network. This figure shows one step of policy roll-out, which demonstrates how the same policy network handles different tasks with different grammar G 1 and G 2.Now we are able to build our policy network in an auto-regressive way. Specifically, the policy π(f |φ, G) can be parameterized as: DISPLAYFORM1 Here the probability of each action (in other words, each tree expansion decision) is defined as π(a t |h(G), DISPLAYFORM2, where s t ∈ R d is the context vector that captures the state of h(G) and T (t−1). In our implementation, s t is tracked by a LSTM decoder whose hidden state is updated by the embedding of the chosen action h αt. The initial state s 0 is obtained by passing graph embedding h(G) through a dense layer with matching size. In this section, we present a reinforcement learning framework for the meta-solver. Formally, let θ denote the parameters of graph embedding and adaptive policy network. For a given pair of instances (φ, G), we learn a policy π θ (f |φ, G) parameterized by θ that generates f such that φ ≡ f.Reward design: The RL episode starts by accepting the representation of tuple φ, G as initial observation. During the episode, the model executes a sequence of actions to expand non-terminals in f, and finishes the episode when f is complete. Upon finishing, the SAT solver is invoked and will return a binary flag indicating whether f satisfies φ or not. An obvious reward design would be directly using the binary value as the episode return. However, this leads to a high variance in returns as well as a highly non-smooth loss surface. Here, we propose to smooth the reward as follows: for each specification φ we maintain a test case buffer B φ that stores all input examples observed so far. Each time the SAT solver is invoked for φ, if f passes then a full reward of 1 is given, otherwise the solver will generate a counter-example b besides the binary flag. We then sample interpolated examples around b which we denote the set asB b. Then the reward is given as the fractions of examples in B φ andB b where f has the equivalent output as φ r = DISPLAYFORM0 At the end of the episode, the buffer is updated as B φ ← B φ ∪B b for next time usage. In the extreme case where all inputs can be enumerated, e.g. binary or discrete values, it reduces to computing the fraction of passed examples over the entire test case set. This is implemented in our experiment on the cryptographic circuit synthesis task. In the meta-learning setting, the framework learns to represent a set of different programs and navigate the generation process under different constraints. We utilize the Advantage Actor-Critic (A2C) for model training. Given a training set D, a minibatch of instances are sampled from D for each epoch. For each instance φ i, G i, the model performs a complete rollout using policy π θ (f |φ i, G i).The actor-critic method computes the gradients w.r.t to θ of each instance as DISPLAYFORM0 where γ denotes the discounting factor and V (s t ; ω) is a state value estimator parameterized by ω. In our implementation, this is modeled as a standard MLP with scalar output. It is learned to fit the expected return, i.e., min ω E |f | t=1 γ t r − V (s t ; ω). Gradients obtained from each instance are averaged over the minibatch before applying to the parameter. Figure 3: An example of a circuit synthesis task from the 2017 SyGuS competition. Given the original program specification which is represented as an abstract syntax tree (left), the solver is tasked to synthesize a new circuit f (right). The synthesis process is specified by the syntactic constraint G (top), and the semantic constraint (bottom) specifies that f must have functionality equivalent to the original program. We evaluate the our framework 1 on cryptographic circuit synthesis tasks BID17 which constitute a challenging benchmark suite from the general track of the. The dataset contains 214 tasks, each of which is a pair of logical specification, describing the correct functionality, and a context free grammar, describing the timing constraints for input signals. The goal is to find an equivalent logical expression which is required to follow the given context free grammar in order to avoid potential timing channel vulnerabilities. Figure 3 shows an illustrative example. Each synthesis task has a different logical specification as well as timing constraints, and both the logical specification and context free grammar varies from task to task, posing a significant challenge in representation learning. As a , this suite of tasks serves as an ideal testbed for our learning framework and its capability to generalize to unseen specifications and grammars. The experiments are conducted in two learning settings. First, we test our framework as an outof-box solver, which means the training set D and testing set D are the same and contain only one instance. In other words, the framework is tasked to solve only one instance at a time. This test-on-train setting serves to investigate the capacity of our framework in representation and policy learning, as the model can arbitrarily "exploit" the problem without worrying about overfitting. This setting also enables us to compare our framework to classical solvers developed in the formal methods community. As those solvers do not utilize learning-based strategies, it is sensible to also limit our framework not to carry over prior knowledge from a separate training set. Second, we evaluate the model as a meta-solver which is trained over a training set D, and finetuned on each of the new tasks in a separate set D. In this setting, we aim to demonstrate that our Table 1: Number of instances solved using: 1) EUSolver, 2) CVC4, 3) ESymbolic, and 4) Out-ofBox Solver. For each solver, the maximum time in solving an instance and the average and median time over all solved instances are also shown below. framework is capable of learning a transferable representation and policy in order to efficiently adapt to unseen tasks. In the out-of-box solver setting, we compare our framework against solvers built based on two classical approaches: a SAT/SMT constraint solving based approach and a search based approach. For the former, we choose CVC4 BID36, which is the state-of-the-art SMT constraint solver; for the latter, we choose EUSolver BID5, which is the winner of the SyGuS 2017 Competition BID4. Furthermore, we build a search based solver as baseline, ESymbolic, which systematically expands non-terminals in a predefined order (e.g. depth-first-search) and effectively prunes away partially generated candidates by reducing it to 2QBF BID6 satisfiability check. ESymbolic can be viewed as a generalization of EUSolver by replacing the carefully designed domain-specific heuristics (e.g. indistinguishability and unification) with 2QBF.In order to make the comparison fair, we run all solvers on the same platform with a single core CPU available 2, even though our framework could take advantage of hardware accelerations, for instance, via GPUs and TPUs. We measure the performance of each solver by counting the number of instances it can solve given a 6 hours limit spent on each task. It is worth noting that comparing running time only gives a limited view of the solvers' performance. Although the hardware is the same, the software implementation can make many differences. For instance, CVC4 is carefully redesigned and re-implemented in C++ as the successor of CVC3 , which has been actively improved for more than a decade. To our best knowledge, the design and implementation of EUSolver is directly guided by and heavily tuned according to SyGuS benchmarks. In contrast, our framework is a proof-of-concept prototype implemented in Python and has not yet been tuned for running time performance. In Table 1, we summarize the total number of instances solved by each solver as well as the maximum, average and median running time spent on solved instances. In terms of the absolute number of solved instances, our framework is not yet as good as EUSolver, which is equipped with specialized heuristics. However, EUSolver fails to solve 4 instances that are only solved by our framework. All instances solved by CVC4 and ESymbolic are a strict subset of instances solved by EUSolver. Thus, besides being a new promising approach, our framework already plays a supplementary role for improving the current state-of-the-art. Compared with the state-of-the-art CVC4 solver, our framework has smaller maximum time but higher average and median time usage. This suggests that our framework excels at solving difficult instances with better efficiency. This observation is further confirmed in FIG3, where we plot the time usage along with the number of instances solved. This suggests that canonical solvers such as CVC4 are efficient in solving simple instances, but have inferior scalability compared to our dynamically adapted approach when the problem becomes more difficult, where we can see a steeper increase in time usages by CVC4 in solving 110 and more instances. Though EUSolver has superior scalability, it is achieved by a number of heuristics that are manually designed and iteratively improved by experts with the same benchmark on hand. In contrast, our framework learns a policy to solve hard instances from scratch on the fly without requiring training data at all. We next evaluate whether our framework is capable of learning transferable knowledge across different synthesis tasks. We randomly split the 214 circuits synthesis tasks into two sets: 150 tasks for training and the rest 64 tasks for testing. The meta-solver is then trained on the training set for 35000 epochs using methods introduced in Sec 4.1. For each epoch, a batch of 10 tasks are sampled. The gradients of each task are averaged and applied to the model parameters using Adam optimizer. In testing phase, the trained meta-solver is finetuned on each task in the testing set until either a correct program is synthesized or timeout occurs. This process is similar to the setting in Sec 5.1 but with smaller learning rate and exploration. We compare the trained meta-solver with the out-of-box solver in solving tasks in the test set. Out of 64 testing tasks, the out-of-box solver and meta-solver can solve 36 and 37 tasks, respectively. Besides the additional task solved, the performance is also greatly improved by meta-solver, which is shown in FIG4. Table 5 (a) shows the accumulated number of candidates generated to successfully solve various ratios of testing tasks. We see that the number of explored candidates by meta-solver is significantly reduced: for 40% of testing tasks (i.e., 66% of solved tasks), meta-learning enable 4x reduction on average. The accumulated reduction for all solved tasks (60% of testing tasks) is not that significant. This is because meta-learning improve dramatically for most (relatively) easy tasks but helps slightly for a few hard tasks, which actually dominate the number of generated candidates. FIG4 (b) shows the speedup distribution over the 36 commonly solved tasks. Meta-solver achieves at least 2x speedup for most benchmarks, orders of magnitude improvement for 10 out of 36 unseen tasks, and solves one task that is not solvable without meta-learning. We survey work on symbolic program synthesis, neural program synthesis, and neural induction. Symbolic program synthesis. Automatically synthesizing a program from its specification was first posed by BID30. It received renewed attention with advances in SAT and SMT solvers BID41 and found application in problems in various domains as surveyed by BID22. In this context, SyGuS BID3 was proposed as a common format to express these problems. Several implementations of SyGuS solvers exist, including by constraint solving BID36, divide-and-conquer BID5, and stochastic MCMC search BID37, in addition to various domain-specific algorithms. A number of probabilistic techniques have been proposed to accelerate these solvers by modeling syntactic aspects of programs. These include PHOG BID27, log-bilinear tree-traversal models BID29, and graph-based statistical models.Neural program synthesis. Several recent works have used neural networks to accelerate the discovery of desired programs. These include DeepCoder BID7, Bayou BID31, RobustFill BID16, Differentiable FORTH BID10, neurosymbolic program synthesis BID33 BID11, neural-guided deductive search BID43, learning context-free parsers BID13, and learning program invariants BID39. The syntactic specification in these approaches is fixed by defining a domain-specific language upfront. Also, with the exception of BID39, the semantic specification takes the form of input-output examples. Broadly, these works have difficulty with symbolic constraints, and are primarily concerned with avoiding overfitting, coping with few examples, and tolerating noisy examples. Our work relaxes both these kinds of specifications to target the general SyGuS formulation. Recently BID18 propose gradually bootstrapping domain-specific languages for neurally-guided Bayesian program learning, while our work concerns learning programs that use similar grammars, which may or may not be incremental. Neural program induction. Another body of work includes techniques in which the neural network is itself the computational substrate. These include neural Turing machines BID20 ) that can learn simple copying/sorting programs, the neural RAM model BID25 to learn pointer manipulation and dereferencing, the neural GPU model BID24 to learn complex operations like binary multiplication, and BID12's work to incorporate recursion. These approaches have fundamental problems regarding verifying and interpreting the output of neural networks. In contrast, we propose tightly integrating a neural learner with a symbolic verifier so that we obtain the scalability and flexibility of neural learning and the correctness guarantees of symbolic verifiers. We proposed a framework to learn a transferable representation and strategy in solving a general formulation of program synthesis, i.e. syntax-guided synthesis (SyGuS). Compared to previous work on neural synthesis, our framework is capable of handling tasks where 1) the grammar and semantic specification varies from task to task, and 2) the supervision is weak. Specifically, we introduced a graph neural network that can learn a joint representation over different pairs of syntactic and semantic specifications; we implemented a grammar adaptive network that enables program generation to be conditioned on the specific task; and finally, we proposed a meta-learning method based on the Advantage Actor-Critic (A2C) framework. We compared our framework empirically against one baseline following a similar search fashion and two classical synthesis engines. Under the outof-box solver setting with limited computational resources and without any prior knowledge from training, our framework is able to solve 141 of 214 tasks, significantly outperforming the baseline ESymbolic by 110. In terms of the absolute number of solved tasks, the performance is comparable to two state-of-the-art solvers, CVC4 and EUSolver, which solve 129 and 153 respectively. However, the two state-of-the-art solvers failed on 4 tasks solved by our framework. When trained as a meta-solver, our framework is capable of accelerating the solving process by 2× to 100×."

Introduction of a new optimization method and its application to deep learning.

represent the tldr for finding the corresponding scientific article.

We prove that for a large class of functions f there exists an interval certified robust network approximating f up to arbitrary precision.


Question: Represent the article for finding a single-sentence TLDR:

Question: We introduce Quantum Graph Neural Networks (QGNN), a new class of quantum neural network ansatze which are tailored to represent quantum processes which have a graph structure, and are particularly suitable to be executed on distributed quantum systems over a quantum network. Along with this general class of ansatze, we introduce further specialized architectures, namely, Quantum Graph Recurrent Neural Networks (QGRNN) and Quantum Graph Convolutional Neural Networks (QGCNN). We provide four example applications of QGNN's: learning Hamiltonian dynamics of quantum systems, learning how to create multipartite entanglement in a quantum network, unsupervised learning for spectral clustering, and supervised learning for graph isomorphism classification. Variational Quantum Algorithms are a promising class of algorithms are rapidly emerging as a central subfield of Quantum Computing (; ;). Similar to parameterized transformations encountered in deep learning, these parameterized quantum circuits are often referred to as Quantum Neural Networks (QNNs). Recently, it was shown that QNNs that have no prior on their structure suffer from a quantum version of the no-free lunch theorem and are exponentially difficult to train via gradient descent. Thus, there is a need for better QNN ansatze. One popular class of QNNs has been Trotter-based ansatze . The optimization of these ansatze has been extensively studied in recent works, and efficient optimization methods have been found (b;). On the classical side, graph-based neural networks leveraging data geometry have seen some recent successes in deep learning, finding applications in biophysics and chemistry . Inspired from this success, we propose a new class of Quantum Neural Network ansatz which allows for both quantum inference and classical probabilistic inference for data with a graph-geometric structure. In the sections below, we introduce the general framework of the QGNN ansatz as well as several more specialized variants and showcase four potential applications via numerical implementation. Graph Neural Networks (GNNs) date back to who applied neural networks to acyclic graphs. and developed methods that learned node representations by propagating the information of neighbouring nodes. Recently, GNNs have seen great breakthroughs by adapting the convolution operator from CNNs to graphs (; ; ; ; ; ;). Many of these methods can be expressed under the message-passing framework . n×n is the adjacency matrix, and X ∈ R n×d is the node feature matrix where each node has d features. where H (k) ∈ R n×d are the node representations computed at layer k, P is the message propagation function and is dependent on the adjacency matrix, the previous node encodings and some learnable parameters W (k). The initial embedding, H is naturally X. One popular implementation of this framework is the GCN which implements it as follows: whereÃ = A + I is the adjacency matrix with inserted self-loops,D = jÃ ij is the renormalization factor (degree matrix). Consider a graph G = {V, E}, where V is the set of vertices (or nodes) and E the set of edges. We can assign a quantum subsystem with Hilbert space H v for each vertex in the graph, forming a global Hilbert space H V ≡ v∈V H v. Each of the vertex subsystems could be one or several qubits, a qudit, a qumode , or even an entire quantum computer. One may also define a Hilbert space for each edge and form H E ≡ e∈E H e. The total Hilbert space for the graph would then be H E ⊗ H V. For the sake of simplicity and feasibility of numerical implementation, we consider this to be beyond the scope of the present work. The edges of the graph dictate the communication between the vertex subspaces: couplings between degrees of freedom on two different vertices are allowed if there is an edge connecting them. This setup is called a quantum network with topology given by the graph G. The most general Quantum Graph Neural Network ansatz is a parameterized quantum circuit on a network which consists of a sequence of Q different Hamiltonian evolutions, with the whole sequence repeated P times:Û where the product is time-ordered , the η and θ are variational (trainable) parameters, and the HamiltoniansĤ q (θ) can generally be any parameterized Hamiltonians whose topology of interactions is that of the problem graph: Here the W qrjk and B qrv are real-valued coefficients which can generally be independent trainable parameters, forming a collection are Hermitian operators which act on the Hilbert space of the j th node of the graph. The sets I jk and J v are index sets for the terms corresponding to the edges and nodes, respectively. To make compilation easier, we enforce that the terms of a given HamiltonianĤ q commute with one another, but differentĤ q's need not commute. In order to make the ansatz more amenable to training and avoid the barren plateaus (quantum parametric circuit no free lunch) problem , we need to add some constraints and specificity. To that end, we now propose more specialized architectures where parameters are tied spatially (convolutional) or tied over the sequential iterations of the exponential mapping (recurrent). We define quantum graph recurrent neural networks as ansatze of the form of equation 3 where the temporal parameters are tied between iterations, η pq → η q. In other words, we have tied the parameters between iterations of the outer sequence index (over p = 1, . . ., P). This is akin to classical recurrent neural networks where parameters are shared over sequential applications of the recurrent neural network map. As η q acts as a time parameter for Hamiltonian evolution under H q, we can view the QGRNN ansatz as a Trotter-based quantum simulation of an evolution e −i∆Ĥ eff under the HamiltionianĤ eff = ∆ −1 q η qĤq for a time step of size ∆ = η 1 = q |η q |. This ansatz is thus specialized to learn effective quantum Hamiltonian dynamics for systems living on a graph. In Section 3 we demonstrate this by learning the effective real-time dynamics of an Ising model on a graph using a QGRNN ansatz. Classical Graph Convolutional neural networks rely on a key feature: that of permutation invariance. In other words, the ansatz should be invariant under permutation of the nodes. This is analogous to translational invariance for ordinary convolutional transformations. In our case, permutation invariance manifests itself as a constraint on the Hamiltonian, which now should be devoid of local trainable parameters, and should only have global trainable parameters. The θ parameters thus become tied over indices of the graph: W qrjk → W qr and B qrv → B qr. A broad class of graph convolutional neural networks we will focus on is the set of so-called Quantum Alternating Operator Ansatze , the generalized form of the Quantum Approximate Optimization Algorithm ansatz . We can take inspiration from the continuous-variable quantum approximate optimization ansatz introduced in Verdon et al. (2019a) to create a variant of the QGCNN: the Quantum Spectral Graph Convolutional Neural Network (QSGCNN). We show here how it recovers the mapping of Laplacianbased graph convolutional networks in the Heisenberg picture, consisting of alternating layers of message passing, node update, and nonlinearities. Consider an ansatz of the form from equation 3 with four different Hamiltonians (Q = 4) for a given graph. First, for a weighted graph G with edge weights Λ jk, we define the coupling Hamiltonian aŝ The Λ jk here are the weights of the graph G, and are not trainable parameters. The operators denoted here byx j are quantum continuous-variable position operators, which can be implemented via continuous-variable (analog) quantum computers or emulated using multiple qubits on digital quantum computers . After evolving byĤ C, which we consider to be the message passing step, one applies an exponential of the kinetic Hamiltonian,Ĥ K ≡ 1 2 j∈Vp 2 j. Herep j denotes the continuous-variable momentum (Fourier conjugate) of the position, obeying the canonical commutation relation [x j,p j] = iδ jk. We consider this step as a node update step. In the Heisenberg picture, the evolution generated by these two steps maps the position operators of each node according to where L jk = δ jk v∈V Λ jv − Λ jk is the Graph Laplacian matrix for the weighted graph G. We can recognize this step as analogous to classical spectral-based graph convolutions. One difference to note here is that momentum is free to accumulate between layers. Next, we must add some non-linearity in order to give the ansatz more capacity. 1 The next evolution is thus generated by an anharmonic HamiltonianĤ A = j∈V f (x j), where f is a nonlinear function of degree greater than 2, e.g., a quartic potential of the form f (x j) = ((x j − µ) 2 − ω 2 ) 2 for some µ, ω hyperparameters. Finally, we apply another evolution according to the kinetic Hamiltonian. These last two steps yield an update which acts as a nonlinear mapping. By repeating the four evolution steps described above in a sequence of P layers, i.e., with variational parameters θ = {α, β, γ, δ}, we then recover a quantum-coherent analogue of the node update prescription of in the original graph convolutional networks paper. Learning the dynamics of a closed quantum system is a task of interest for many applications , including device characterization and validation. In this example, we demonstrate that a Quantum Graph Recurrent Neural Network can learn effective dynamics of an Ising spin system when given access to the output of quantum dynamics at various times. Our target is an Ising Hamiltonian with transverse field on a particular graph, We are given copies of a fixed low-energy state |ψ 0 as well as copies of the state |ψ T ≡ U (T) |ψ 0 = e −iTĤtarget for some known but randomly chosen times T ∈ [0, T max]. Our goal is to learn the target Hamiltonian parameters {J jk, Q v} j,k,v∈V by comparing the state |ψ T with the state obtained by evolving |ψ 0 according to the QGRNN ansatz for a number of iterations P ≈ T /∆ (where ∆ is a hyperparameter determining the Trotter step size). We achieve this by training the parameters via Adam gradient descent on the average infidelity 2 averaged over batch sizes of 15 different times T. Gradients were estimated via finite difference differentiation with step size = 10 −4. The fidelities (quantum state overlap) between the output of our ansatz and the time-evolved data state were estimated via the quantum swap test . The ansatz uses a Trotterization of a random densely-connected Ising Hamiltonian with transverse field as its initial guess, and successfully learns the Hamiltonian parameters within a high degree of accuracy as shown in Fig. 1a. A picture of the quantum network topology is inset. Right: Quantum phase kickback test on the learned GHZ state. We observe a 7x boost in Rabi oscillation frequency for a 7-node network, thus demonstrating we have reached the Heisenberg limit of sensitivity for the quantum sensor network. Quantum Sensor Networks are a promising area of application for the technologies of Quantum Sensing and Quantum Networking/Communication . A common task considered where a quantum advantage can be demonstrated is the estimation of a parameter hidden in weak qubit phase rotation signals, such as those encountered when artificial atoms interact with a constant electric field of small amplitude . A well-known method to achieve this advantange is via the use of a quantum state exhibiting multipartite entanglement of the Greenberger-Horne-Zeilinger kind, also known as a GHZ state . Here we demonstrate that, without global knowledge of the quantum network structure, a QGCNN ansatz can learn to prepare a GHZ state. We use a QGCNN ansatz withĤ 1 = {j,k}∈EẐ jẐk andĤ 2 = j∈VX j. The loss function is the negative expectation of the sum of stabilizer group generators which stabilize the GHZ state (Tóth & Gühne, 2005), i.e., for a network of n qubits. Results are presented in Fig. 1b. Note that the advantage of using a QGNN ansatz on the network is that the number of quantum communication rounds is simply proportional to P, and that the local dynamics of each node are independent of the global network structure. In order to further validate that we have obtained an accurate GHZ state on the network after training, we perform the quantum phase kickback test on the network's prepared approximate GHZ state . 3 We observe the desired frequency boost effect for our trained network preparing an approximate GHZ state at test time, as displayed in Figure 2. As a third set of applications, we consider applying the QSGCNN from Section 2 to the task of spectral clustering . Spectral clustering involves finding low-frequency eigenvalues of the graph Laplacian and clustering the node values in order to identify graph clusters. In Fig. 3 we present the for a QSGCNN for varying multi-qubit precision for the representation of the continuous values, where the loss function that was minimized was the expected value of the anharmonic potential L(η) = Ĥ C +Ĥ A η. Of particular interest to near-term quantum computing with low numbers if qubits is the single-qubit precision case, where we modify the QSGCNN construction asp 2 j →X j, 3 For this test, one applies a phase rotation j∈V e −iϕẐ j on all the qubits in paralel, then one applies a sequence of CNOT's (quantum adder gates) such as to concentrate the phase shifts onto a single collector node, m ∈ V. Given that one had a GHZ state initially, one should then observe a phase shift e −inϕẐm where n = |V|. This boost in frequency of oscillation of the signal is what gives quantum multipartite entanglement its power to increase sensitivity to signals to super-classical levels . configurations, and to their right is the output probability distribution over potential energies. We see lower energies are most probable and that these configurations have node values clustered. H A → I andx j → |1 1| j which transforms the coupling Hamiltonian aŝ where |1 1| k = (Î −Ẑ k)/2. We see that using a low-qubit precision yields sensible , thus implying that spectral clustering could be a promising new application for near-term quantum devices. Recently, a benchmark of the representation power of classical graph neural networks has been proposed where one uses classical GCN's to identify whether two graphs are isomorphic. In this spirit, using the QSGCNN ansatz from the previous subsection, we benchmarked the performance of this Quantum Graph Convolutional Network for identifying isomorphic graphs. We used the single-qubit precision encoding in order to order to simulate the execution of the quantum algorithms on larger graphs. Our approach was the following, given two graphs G 1 and G 2, one applies the single-qubit precision QSGCNN ansatz P j=1 e iηjĤ K e iγjĤ C withĤ K = j∈VX j andĤ C from equation 5 in parallel according to each graph's structure. One then samples eigenvalues of the coupling HamiltonianĤ C on both graphs via standard basis measurement of the qubits and computation of the eigenvalue at each sample of the wavefunction. One then obtains a set of samples of "energies" of this Hamiltonian. By comparing the energetic measurement statistics output by the QSGCNN ansatz applied with identical parameters θ = {η, γ} for two different graphs, one can then infer whether the graphs are isomorphic. We used the Kolmogorov-Smirnoff test on the distribution of energies sampled at the output of the QSGCNN to determine whether two given graphs were isomorphic. In order to determine the binary classification label deterministically, we considered all KS statistic values above 0.4 to indicate that the graphs were non-isomorphic. For training and testing purposes, we set the For the dataset, graphs were sampled uniformly at random; to prepare a balanced dataset, we selected isomorphic and non-isomorphic pairs. In all of our experiments, we had 100 pairs of graphs for training, 50 for validation, 50 for testing, and in all cases there are balanced isomorphic and nonisomorphic pairs. The networks were trained via Adam gradient-based optimizer with batches of size 50. Presented in Figure 4 is the training and testing losses for various graph sizes and numbers of energetic samples. In Tables 1 and 2, we present the graph isomorphism classification accuracy for the training and testing sets using the trained QGCNN with the previously described thresholded KS statistic as the label. We see we get highly accurate performance even at low sample sizes. This seems to imply that the QGCNN is fully capable of identifying graph isomorphism, as desired for graph convolutional network benchmarks. We leave a comparison to similar scale classical graph convolutional networks to future work. Results featured in this paper should be viewed as a promising set of first explorations of the potential applications of QGNNs. Through our numerical experiments, we have shown the use of these QGNN ansatze in the context of quantum dynamics learning, quantum sensor network optimization, unsupervised graph clustering, and supervised graph isomorphism classification. Given that there is a vast set of literature on the use of Graph Neural Networks and their variants to quantum chemistry, future works should explore hybrid methods where one can learn a graph-based hidden quantum representation (via a QGNN) of a quantum chemical process. As the true underlying process is quantum in nature and has a natural molecular graph geometry, the QGNN could serve as a more accurate model for the hidden processes which lead to perceived emergent chemical properties. We seek to explore this in future work. Other future work could include generalizing the QGNN to include quantum degrees of freedom on the edges, include quantum-optimization-based training of the graph parameters via quantum phase backpropagation , and extending the QSGCNN to multiple features per node.

Represent the TLDR for finding the corresponding scientific article

Introducing a new class of quantum neural networks for learning graph-based representations on quantum computers.

represent the short summary for finding the corresponding scientific article (long)

We show shortcut connections should be placed in patterns that minimize between-layer distances during backpropagation, and design networks that achieve log L distances using L log(L) connections.