CURE: Simulation-Augmented Auto-Tuning in Robotics

Md Abir Hossen^0000-0002-7956-0515, Sonam Kharade^0000-0001-7905-9387, Jason M. O'Kane^0000-0002-1536-4822, Senior Member, IEEE,, Bradley Schmerl^0000-0001-7828-622X, Senior Member, IEEE,
David Garlan^0000-0002-6735-8301, Life Fellow, IEEE, and Pooyan Jamshidi^0000-0002-9342-0703

This work was supported by National Science Foundation (Award 2107463) and National Aeronautics and Space Administration (Award 80NSSC20K1720).
M. A. Hossen, S. Kharade, and P. Jamshidi are with the University of South Carolina, SC, USA (e-mail<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>J. M. O'Kane is with Texas A&M University, TX, USA (e-mail<EMAIL_ADDRESS>B. Schmerl, and D. Garlan are with the Carnegie Mellon University, PA, USA (e-mail<EMAIL_ADDRESS><EMAIL_ADDRESS>
Robotic systems are typically composed of various subsystems, such as localization and navigation, each encompassing numerous configurable components (e.g., selecting different planning algorithms). Once an algorithm has been selected for a component, its associated configuration options must be set to the appropriate values. Configuration options across the system stack interact non-trivially. Finding optimal configurations for highly configurable robots to achieve desired performance poses a significant challenge due to the interactions between configuration options across software and hardware that result in an exponentially large and complex configuration space. These challenges are further compounded by the need for transferability between different environments and robotic platforms. Data efficient optimization algorithms (e.g., Bayesian optimization) have been increasingly employed to automate the tuning of configurable parameters in cyber-physical systems. However, such optimization algorithms converge at later stages, often after exhausting the allocated budget (e.g., optimization steps, allotted time) and lacking transferability. This paper proposes CURE—a method that identifies causally relevant configuration options, enabling the optimization process to operate in a reduced search space, thereby enabling faster optimization of robot performance. abstracts the causal relationships between various configuration options and robot performance objectives by learning a causal model in the source (a low-cost environment such as the Gazebo simulator) and applying the learned knowledge to perform optimization in the target (e.g., Turtlebot 3 physical robot). We demonstrate the effectiveness and transferability of by conducting experiments that involve varying degrees of deployment changes in both physical robots and simulation.

robotics and cyberphysical systems, causal inference, optimization, robot testing

[1]
E. Khalastchi and M. Kalech, “On fault detection and diagnosis in robotic
systems,” ACM Computing Surveys (CSUR), vol. 51, no. 1, pp. 1–24,

[2]
H. Kim, M. O. Ozmen et al., “Patchverif: Discovering faulty patches in
robotic vehicles.”

[3]
C. Jung, A. Ahad et al., “Swarmbug: debugging configuration bugs in
swarm robotics,” in Proceedings of the 29th ACM Joint Meeting on
European Software Engineering Conference and Symposium on the Foundations of
Software Engineering, 2021, pp. 868–880.

[4]
M. A. Hossen, S. Kharade et al., “Care: Finding root causes of
configuration issues in highly-configurable robots,” IEEE Robotics and
Automation Letters, vol. 8, no. 7, pp. 4115–4122, 2023.

[5]
K.-T. Xie, J.-J. Bai et al., “Rozz: Property-based fuzzing for robotic
programs in ros,” in 2022 International Conference on Robotics and
Automation (ICRA).1em plus 0.5em minus 0.4emIEEE, 2022, pp.

[6]
T. Kim, C. H. Kim et al., “Rvfuzzer: Finding input validation bugs in
robotic vehicles through control-guided testing.” in USENIX Security
Symposium, 2019, pp. 425–442.

[7]
D. Wang, S. Li et al., “An exploratory study of autopilot software bugs
in unmanned aerial vehicles,” in Proceedings of the 29th ACM Joint
Meeting on European Software Engineering Conference and Symposium on the
Foundations of Software Engineering, 2021, pp. 20–31.

[8]
J. Garcia, Y. Feng et al., “A comprehensive study of autonomous vehicle
bugs,” in Proceedings of the ACM/IEEE 42nd international conference on
software engineering, 2020, pp. 385–396.

[9]
S. Kim, M. Liu et al., “Drivefuzz: Discovering autonomous driving bugs
through driving quality-guided fuzzing,” in Proceedings of the 2022
ACM SIGSAC Conference on Computer and Communications Security, 2022, pp.

[10]
P. Valle, A. Arrieta et al., “Automated misconfiguration repair of
configurable cyber-physical systems with search: an industrial case study on
elevator dispatching algorithms,” arXiv preprint arXiv:2301.01487,

[11]
Challenges in optimizing configurations for robotic systems in real-world
scenarios. [Online]. Available:

[12]
Automatic parameter tuning feature request in ros navigation2 github issues.
[Online]. Available:

[13]
Local planner performance problem. in ros navigation2 github issues. [Online].
Available: <https://github.com/ros-planning/navigation2/issues/2439>

[14]
L. Meier, D. Honegger et al., “Px4: A node-based multithreaded open
source robotics framework for deeply embedded platforms,” in 2015 IEEE
international conference on robotics and automation (ICRA).1em plus
0.5em minus 0.4emIEEE, 2015, pp. 6235–6240.

[15]
M. Quigley, K. Conley et al., “Ros: an open-source robot operating
system,” in ICRA workshop on open source software, vol. 3, no.
3.2.1em plus 0.5em minus 0.4emKobe, Japan, 2009, p. 5.

[16]
M. A. Hossen, S. Kharade et al., “Care: Finding root causes of
configuration issues in highly-configurable robots,” IEEE Robotics and
Automation Letters, vol. 8, no. 7, pp. 415–4122, Jul. 2023.

[17]
R. B. Abdessalem, A. Panichella et al., “Automated repair of feature
interaction failures in automated driving systems,” in Proceedings of
the 29th ACM SIGSOFT International Symposium on Software Testing and
Analysis, 2020, pp. 88–100.

[18]
T. P. Lillicrap, J. J. Hunt et al., “Continuous control with deep
reinforcement learning,” arXiv preprint arXiv:1509.02971, 2015.

[19]
A. Gupta, A. Murali et al., “Robot learning in homes: Improving
generalization and reducing dataset bias,” Advances in neural
information processing systems, vol. 31, 2018.

[20]
A. Binch, G. P. Das et al., “Context dependant iterative parameter
optimisation for robust robot navigation,” in 2020 IEEE International
Conference on Robotics and Automation (ICRA).1em plus 0.5em minus
0.4emIEEE, 2020, pp. 3937–3943.

[21]
A. Zhou, B.-Y. Qu et al., “Multiobjective evolutionary algorithms: A
survey of the state of the art,” Swarm and evolutionary computation,
vol. 1, no. 1, pp. 32–49, 2011.

[22]
F. Berkenkamp, A. Krause et al., “Bayesian optimization with safety
constraints: safe and automatic parameter tuning in robotics,” Machine
Learning, vol. 112, no. 10, pp. 3713–3747, 2023.

[23]
R. Ariizumi, M. Tesch et al., “Multiobjective optimization based on
expensive robotic experiments under heteroscedastic noise,” IEEE
Transactions on Robotics, vol. 33, no. 2, pp. 468–483, 2016.

[24]
Y. Kim, Z. Pan et al., “Mo-bbo: Multi-objective bilevel bayesian
optimization for robot and behavior co-design,” in 2021 IEEE
International Conference on Robotics and Automation (ICRA).1em plus
0.5em minus 0.4emIEEE, 2021, pp. 9877–9883.

[25]
T. Liao, G. Wang et al., “Data-efficient learning of morphology and
controller for a microrobot,” in 2019 International Conference on
Robotics and Automation (ICRA).1em plus 0.5em minus 0.4emIEEE,
2019, pp. 2488–2494.

[26]
P. Jamshidi, M. Velez et al., “Learning to sample: Exploiting
similarities across environments to learn performance models for configurable
systems,” in Proceedings of the 2018 26th ACM Joint Meeting on
European Software Engineering Conference and Symposium on the Foundations of
Software Engineering, 2018, pp. 71–82.

[27]
A. Rai, R. Antonova et al., “Using simulation to improve
sample-efficiency of bayesian optimization for bipedal robots,” The
Journal of Machine Learning Research, vol. 20, no. 1, pp. 1844–1867, 2019.

[28]
R. Kaushik, K. Arndt et al., “SafeAPT: Safe simulation-to-real robot
learning using diverse policies learned in simulation,” IEEE Robotics
and Automation Letters, vol. 7, no. 3, pp. 6838–6845, 2022.

[29]
P. Valov, J. Guo et al., “Transferring Pareto frontiers across
heterogeneous hardware environments,” in Proceedings of the ACM/SPEC
International Conference on Performance Engineering, 2020, pp. 12–23.

[30]
C. Zhou, X. Ma et al., “Examining and combating spurious features under
distribution shift,” in International Conference on Machine
Learning.1em plus 0.5em minus 0.4emPMLR, 2021, pp.
12 857–12 867.

[31]
M. Diehl and K. Ramirez-Amaro, “Why did i fail? a causal-based method to find
explanations for robot failures,” IEEE Robotics and Automation
Letters, vol. 7, no. 4, pp. 8925–8932, 2022.

[32]
Facebook. Adaptive experimentation platform. [Online]. Available:

[33]
A. E. Hoerl and R. W. Kennard, “Ridge regression: Biased estimation for
nonorthogonal problems,” Technometrics, vol. 12, no. 1, pp. 55–67,

[34]
scikit learn. Ridgecv. [Online]. Available:

[35]
ROS. ROS navigation stack. [Online]. Available:

[36]
P. Spirtes, C. N. Glymour et al., Causation, prediction, and
search.1em plus 0.5em minus 0.4emMIT press, 2000.

[37]
C. Glymour, K. Zhang et al., “Review of causal discovery methods based
on graphical models,” Frontiers in genetics, vol. 10, p. 524, 2019.

[38]
L. M. Connelly, “Fisher's exact test,” MedSurg Nursing, vol. 25,
no. 1, pp. 58–60, 2016.

[39]
D. Colombo, M. H. Maathuis et al., “Learning high-dimensional directed
acyclic graphs with latent and selection variables,” The Annals of
Statistics, pp. 294–321, 2012.

[40]
M. Kocaoglu, S. Shakkottai et al., “Applications of Common Entropy for
Causal Inference,” no. NeurIPS, 2020.

[41]
B. Shahriari, K. Swersky et al., “Taking the human out of the loop: A
review of bayesian optimization,” Proceedings of the IEEE, vol. 104,
no. 1, pp. 148–175, 2015.

[42]
J. Knowles, “Parego: A hybrid algorithm with on-line landscape approximation
for expensive multiobjective optimization problems,” IEEE transactions
on evolutionary computation, vol. 10, no. 1, pp. 50–66, 2006.

[43]
D. Hernández-Lobato, J. Hernandez-Lobato et al., “Predictive
entropy search for multi-objective bayesian optimization,” in
International conference on machine learning.1em plus 0.5em
minus 0.4emPMLR, 2016, pp. 1492–1501.

[44]
W. Ponweiser, T. Wagner et al., “Multiobjective optimization on a
limited budget of evaluations using model-assisted-metric selection,” in
International conference on parallel problem solving from
nature.1em plus 0.5em minus 0.4emSpringer, 2008, pp. 784–794.

[45]
S. Daulton, M. Balandat et al., “Differentiable expected hypervolume
improvement for parallel multi-objective bayesian optimization,”
Advances in Neural Information Processing Systems, vol. 33, pp.
9851–9864, 2020.

[46]
C. E. Rasmussen, C. K. Williams et al., Gaussian processes for
machine learning.1em plus 0.5em minus 0.4emSpringer, 2006,
vol. 1.

[47]
F. Hutter, “Automated configuration of algorithms for solving hard
computational problems,” Thesis, 2009.

[48]
B. Shahriari et al., “Taking the human out of the loop: a review of
bayesian optimization,” Tech. Rep., 2015.

[49]
C. K. Williams and C. E. Rasmussen, “Gaussian processes for machine
learning,” MIT Press, 2006.

[50]
Y. Cao, B. J. Smucker et al., “On using the hypervolume indicator to
compare pareto fronts: Applications to multi-criteria optimal experimental
design,” Journal of Statistical Planning and Inference, vol. 160, pp.
60–74, 2015.

[51]
E. Zitzler and L. Thiele, “Multiobjective evolutionary algorithms: a
comparative case study and the strength pareto approach,” IEEE
transactions on Evolutionary Computation, vol. 3, no. 4, pp. 257–271, 1999.

[52]
M. Chickering, D. Heckerman et al., “Large-sample learning of bayesian
networks is np-hard,” Journal of Machine Learning Research, vol. 5,
pp. 1287–1330, 2004.

[53]
C. Dubslaff, K. Weis et al., “Causality in configurable software
systems,” in Proceedings of the 44th International Conference on
Software Engineering, 2022, pp. 325–337.

[54]
V. Aglietti, X. Lu et al., “Causal bayesian optimization,” in
Proceedings of the Twenty Third International Conference on Artificial
Intelligence and Statistics, ser. Proceedings of Machine Learning Research,
S. Chiappa and R. Calandra, Eds., vol. 108.1em plus 0.5em minus
0.4emPMLR, 26–28 Aug 2020, pp. 3155–3164.

[55]
D. Fox, W. Burgard et al., “The dynamic window approach to collision
avoidance,” IEEE Robotics & Automation Magazine, vol. 4, no. 1, pp.
23–33, 1997.

[56]
B. D. Argall, S. Chernova et al., “A survey of robot learning from
demonstration,” Robotics and autonomous systems, vol. 57, no. 5, pp.
469–483, 2009.

[57]
N. Pérez-Higueras, F. Caballero et al., “Learning human-aware path
planning with fully convolutional networks,” in 2018 IEEE
international conference on robotics and automation (ICRA).1em plus
0.5em minus 0.4emIEEE, 2018, pp. 5897–5902.

[58]
M. Pfeiffer, M. Schaeuble et al., “From perception to decision: A
data-driven approach to end-to-end motion planning for autonomous ground
robots,” in 2017 ieee international conference on robotics and
automation (icra).1em plus 0.5em minus 0.4emIEEE, 2017, pp.

[59]
G. Kahn, P. Abbeel et al., “Badgr: An autonomous self-supervised
learning-based navigation system,” IEEE Robotics and Automation
Letters, vol. 6, no. 2, pp. 1312–1319, 2021.

[60]
T. Chen and M. Li, “Do performance aspirations matter for guiding software
configuration tuning? an empirical investigation under dual performance
objectives,” ACM Transactions on Software Engineering and
Methodology, 2022.

[61]
N. Siegmund, A. Grebhahn et al., “Performance-influence models for
highly configurable systems,” in Proceedings of the 2015 10th Joint
Meeting on Foundations of Software Engineering, 2015, pp. 284–294.

[62]
H. Ha and H. Zhang, “Performance-influence model for highly configurable
software with fourier learning and lasso regression,” in 2019 IEEE
International Conference on Software Maintenance and Evolution (ICSME),
2019, pp. 470–480.

[63]
P. Jamshidi, N. Siegmund et al., “Transfer learning for performance
modeling of configurable systems: An exploratory analysis,” in 2017
32nd IEEE/ACM International Conference on Automated Software Engineering
(ASE).1em plus 0.5em minus 0.4emIEEE, 2017, pp. 497–508.

[64]
J. Ballesteros and L. Fuentes, “Transfer learning for multiobjective
optimization algorithms supporting dynamic software product lines,” in
Proceedings of the 25th ACM International Systems and Software Product
Line Conference-Volume B, 2021, pp. 51–59.

[65]
M. S. Iqbal, Z. Zhong et al., “Cameo: A causal transfer learning
approach for performance optimization of configurable computer systems,”
arXiv preprint arXiv:2306.07888, 2023.

[66]
J. Pearl, Causality.1em plus 0.5em minus 0.4emCambridge
university press, 2009.

[67]
A. Fariha, S. Nath et al., “Causality-guided adaptive interventional
debugging,” in Proceedings of the 2020 ACM SIGMOD International
Conference on Management of Data, 2020, pp. 431–446.

[68]
B. Johnson, Y. Brun et al., “Causal testing: understanding defects'
root causes,” in Proceedings of the ACM/IEEE 42nd International
Conference on Software Engineering, 2020, pp. 87–99.

[69]
C. Dubslaff, K. Weis et al., “Causality in configurable software
systems,” in Proceedings of the 44th International Conference on
Software Engineering, ser. ICSE '22.1em plus 0.5em minus 0.4emNew York, NY, USA: Association for Computing Machinery, 2022, p. 325–337.

[70]
Y. Küçük, T. A. D. Henderson et al., “Improving fault localization
by integrating value and predicate based causal inference techniques,” in
2021 IEEE/ACM 43rd International Conference on Software Engineering
(ICSE), 2021, pp. 649–660.

[71]
D. Colombo and M. H. Maathuis, “Order-independent constraint-based causal
structure learning,” The Journal of Machine Learning Research,
vol. 15, no. 1, pp. 3741–3782, 2014.

[72]
J. Pearl, M. Glymour et al., Causal inference in statistics: A
primer.1em plus 0.5em minus 0.4emJohn Wiley & Sons, 2016.

[73]
T. Richardson and P. Spirtes, “Ancestral graph markov models,” The
Annals of Statistics, vol. 30, no. 4, pp. 962–1030, 2002.

[74]
R. J. Evans and T. S. Richardson, “Markovian acyclic directed mixed graphs for
discrete data,” 2014.


# Training Quantum Neural Networks on NISQ Devices

Kerstin Beer  Daniel List  Gabriel Müller<EMAIL_ADDRESS>Tobias
J. Osborne  Christian Struckmann<EMAIL_ADDRESS>Institut für
Theoretische Physik, Leibniz Universität Hannover, Germany

The advent of noisy intermediate-scale quantum (NISQ) devices offers crucial
opportunities for the development of quantum algorithms. Here we evaluate the
noise tolerance of two quantum neural network (QNN) architectures on IBM’s
NISQ devices, namely, _dissipative QNN_ (DQNN) whose building-block perceptron
is a completely positive map, and the _quantum approximate optimization
algorithm_ (QAOA). We compare these two approaches to learning an unknown
unitary. While both networks succeed in this learning task, we find that a
DQNN learns an unknown unitary more reliably than QAOA and is less susceptible
to gate noise.

##  I Introduction

The classical simulation of many body quantum systems is fundamentally limited
by the exponential growth – in the system size – of the required computational
resources. It was Feynman who first understood that what would become quantum
computing can overcome this obstruction and offer classically unattainable
computational possibilities [1]. This dream has come much closer to reality,
particularly in the past year, as progress on engineering quantum computers
has accelerated rapidly. In parallel, the exploration of various quantum
algorithms is progressing steadily, already leading to early implementations
of _quantum machine learning_ [2, 3, 4].

Quantum machine learning models executed on quantum computers are expected to
outperform their classical counterparts in numerous tasks (see, e.g., [2, 5]
and references therein for a cross-section of results). Such models are
largely implemented as parameterized quantum circuits [6, 7, 8, 9] which are
executed on a quantum computer and whose parameters are variationally
optimized via classical side computation [10, 11, 12, 8].

In recent years a variety of parametrized quantum circuit architectures for
quantum machine learning have been proposed [4]. Prominent amongst these are
_quantum neural networks_ (QNNs), defined by quantum analogy with classical
neural networks. Their fundamental building block, the _quantum perceptron_ ,
has been defined in many ways [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28]. QNNs have been successfully used to learn unitaries [13, 29],
perform classifications tasks [15, 14, 30], and denoise quantum data [31, 32,
24], to name a few applications. The focus of this paper is on the model of
[13], who define a quantum perceptron to be a completely positive map, leading
to _dissipative_ QNN (DQNN) 111Note that, contrary to what the name perhaps
suggests, DQNN are universal for quantum computation and can equally simulate
both unitary and dissipative quantum processes.. An alternative parametrized
quantum circuit class which has attracted considerable interest for its
practical benefits in implementations is that arising in the _quantum
approximate optimization algorithm_ (QAOA), which features a sequence of
alternating unitary operators [34, 35, 36]. This variational class of quantum
circuits has led to promising results for learning unitaries [37] and solving
combinatorial problems [38, 39, 40, 41, 42, 43, 44, 45, 46].

Successfully executing QNNs and the QAOA on today’s _noisy intermediate-scale
quantum_ (NISQ) devices [47] remains extremely challenging [48]. When
exploiting gradient-based training methods, the presence of Barren plateaus,
i.e., exponentially vanishing cost gradients, can significantly diminish their
performance [49, 50, 51, 52]. The increasing noise levels in higher-depth
quantum circuits also poses a major challenge for accurately computing costs
and gradients [41, 53, 54, 47]. Thus, any approach to implementing these
algorithms on currently available quantum hardware must be evaluated and
optimized for their noise tolerance.

In this paper we exploit, and compare, DQNN and QAOA on current quantum
hardware. The task we evaluate is that of learning an unknown unitary
operator. The DQNN is implemented as a parameterized quantum circuit which is
trained via gradient descent; the architecture of the resulting quantum
circuit is optimized to mitigate the effect of noise. We compare the DQNN
circuit with a similar implementation via the QAOA [34], where the QAOA is
described as a QNN. A notable difference between these approaches, is how the
input information propagates through the network. In the case of DQNN,
perceptron maps act on layers of different qubits, whereas the QAOA defines
them as a sequence of operations on the same qubits. Both quantum circuits are
implemented via Qiskit [55] and executed on simulated and real quantum devices
hosted by IBM [56].

Our paper is organized as follows: In Section II, we review the network model
and the corresponding quantum circuit for DQNN and the QAOA. Section III
features the architecture-specific details and implementation of learning via
gradient descent. In Section IV we present our numerical results, where we
compare both networks in terms of their robustness to noise and their
generalization capabilities. Concluding remarks are found in Section V.

Figure 1: Implementation of the DQNN and the QAOA. The complete quantum
circuit (a) consists of three parts: i) the initialization of the first two
$m$ qubits in the target output state $\ket{\phi^{\mathrm{out}}}$ and input
state $\ket{\phi^{\mathrm{in}}}$, respectively, ii) a QNN circuit that
implements either the DQNN ($n\geq m$) or the QAOA ($n=0$), and iii) the
fidelity measurement between the first $m$ and the last $m$ qubits via the
destructive swap test. The DQNN (b) features one input layer, $L$ hidden
layers, and one output layer with $m_{l}$ neurons, respectively. Each neuron
is represented by an individual qubit. Two neighboured layers, $l-1,l$, are
connected through the layer unitary $U^{l}$. The QAOA (c) consists of a
sequence of alternating unitary operators $e^{-iAt_{l}},e^{-iB\tau_{l}}$ with
$l=1,\dots,N$. It can be interpreted as an $\left(N+1\right)$-layer QNN with
$m$ neurons per layer where the operator pair $l$ connects the layers $l-1,l$.
The quantum circuit only requires $m$ qubits such that all unitaries act on
the same qubits.

##  II Network Models

In this section we review DQNNs and the QAOA and, for each network, describe
the network model and its implementation as a quantum circuit.

###  II.1 Dissipative QNN

The general structure of a DQNN is described in [13]. It features one input
layer ($l=0$), $L\geq 0$ hidden layers ($l=1,2,\dots,L$), and one output layer
($l=L+1$). The input and output layers consist of $m=m_{0}=m_{L+1}$ neurons,
respectively, while the hidden layers consist of an arbitrary number of
neurons $m_{l}\geq 1$. (Generally, $m_{L+1}\neq m_{0}$ is possible but would
correspond to a non-unitary transformation, which is out of the scope of the
current paper.) The input neurons are initialized in a given state
$\ket{\phi^{\mathrm{in}}}$ while the neurons of the remaining layers are
initialized in the vacuum product state $\ket{0...0}_{l}$. Two neighboured
layers, $l-1$ and $l$, are fully connected via the layer unitary
$U^{l}=U^{l}_{m_{l}}...U^{l}_{1}$. The quantum perceptron $U^{l}_{j}$ is
defined neuron-wise as a general unitary operator acting on all $m_{l-1}$
neurons of layer $l-1$ and the $j$th neuron of layer $l$. Layer by layer, the
unitary $U^{l}$ is applied to all input states (layer $l-1$) and output states
(layer $l$). The states related to layer $l-1$ are traced out afterward
leaving only the output state of the remaing qubits as an input for the next
layer. The resulting evolution is hence given, in general, by a completely
positive map. This iterative process induces the feed-forward nature of the
network. Thus, the network’s final output state $\rho^{\mathrm{out}}$ is
obtained by:

$\rho^{\mathrm{out}}\equiv\operatorname{tr}_{\mathrm{in,hid}}\left(\mathcal{U}\left(\rho^{\mathrm{in}}\otimes|0\cdots
0\rangle_{\text{hid,out}}\langle 0\cdots
0|\right)\mathcal{U}^{\dagger}\right),$ (1)

where the network unitary is $\mathcal{U}=U^{L+1}...U^{1}$ and the input state
$\rho^{\mathrm{in}}=\ket{\phi^{\mathrm{in}}}\bra{\phi^{\mathrm{in}}}$.

#### The quantum circuit

For our concrete implementation of a DQNN we represent each neuron with a
corresponding qubit yielding a quantum circuit on $M=\sum^{L+1}_{l=0}m_{l}$
qubits. The network’s $2^{M}$-dimensional Hilbert space is the tensor product
of $M$ single-qubit Hilbert spaces. The quantum perceptron $U^{l}_{j}$ is
composed of two-qubit canonical gates
$\operatorname{\mathrm{CAN}}(t_{1},t_{2},t_{3})$ [57]. To guarantee the
network’s universality, additional single-qubit gates $u(\theta,\phi,\lambda)$
are applied to all qubits. The canonical gate is composed of three two-qubit
gates:

$\begin{split}\operatorname{\mathrm{CAN}}(t_{1},t_{2},t_{3})&=e^{-i\frac{\pi}{2}t_{1}X\otimes
X}e^{-i\frac{\pi}{2}t_{2}Y\otimes Y}e^{-i\frac{\pi}{2}t_{3}Z\otimes Z}\\\
&=\operatorname{\mathrm{RXX}}(t_{1}\pi)\operatorname{\mathrm{RYY}}(t_{2}\pi)\operatorname{\mathrm{RZZ}}(t_{3}\pi),\end{split}$
(2)

where $X=\big{(}\begin{smallmatrix}0&1\\\ 1&0\end{smallmatrix}\big{)},$
$Y=\big{(}\begin{smallmatrix}0&-i\\\ i&0\end{smallmatrix}\big{)},$ and
$Z=\big{(}\begin{smallmatrix}1&0\\\ 0&-1\end{smallmatrix}\big{)}$ are the
Pauli matrices and $t_{1,2,3}\in\mathbb{R}$. The single-qubit gate
$u(\theta,\phi,\lambda)$ is defined as

$u(\theta,\phi,\lambda)=\begin{pmatrix}\cos(\theta/2)&-e^{i\lambda}\sin(\theta/2)\\\
e^{i\phi}\sin(\theta/2)&e^{i(\lambda+\phi)}\cos(\theta/2)\end{pmatrix},$ (3)

where $\theta,\phi,\lambda\in\mathbb{R}$.

The quantum circuit simulating a DQNN is structured layer-wise. The first $m$
qubits are initialized in a given state $\ket{\phi^{\mathrm{in}}}$, while all
remaining qubits are initialized in $\ket{0}$. The $u$ gates are applied
first, layer by layer ($l=1,...,L+1$), to all $m_{l-1}$ input qubits. After
that, the layer unitary $U^{l}=\prod^{1}_{m_{l}}U_{j}^{l}$ is applied to all
input and output qubits. Here, $U_{j}^{l}$ is a sequence of $m_{l-1}$
$\operatorname{\mathrm{CAN}}$ gates where the $i$th
$\operatorname{\mathrm{CAN}}$ gate acts on the $i$th input and the $j$th
output qubit. After each layer $l$, the $m_{l-1}$ input qubits are neglected.
The $m_{l}$ output qubits of this layer serve as the input qubits for the next
layer $l+1$. By this, the partial trace of Eq. 1 is realized. After the output
layer $L+1$, again, $u$ gates are applied to the remaining $m$ output qubits.
Thus, the quantum circuit consists of
$N_{p}=3m+3\sum^{L+1}_{l=1}m_{l-1}(1+m_{l})$ parameters. This procedure is
illustrated in Fig. 1b for a  DQNN.

###  II.2 QAOA

The QAOA consists of a sequence of alternating unitary operators
$e^{-iAt_{l}},e^{-iB\tau_{l}}\in U(d)$, where $t_{l},\tau_{l}\in\mathbb{R}$
and $A$ and $B$ are hermitian matrices initially randomly generated from the
gaussian unitary ensemble [34]. The total action of $N$ such operator pairs
can be written as

$\mathcal{U}=e^{-iB\tau_{N}}e^{-iAt_{N}}\cdots e^{-iB\tau_{1}}e^{-iAt_{1}}$
(4)

so that the output state is given by $\rho^{\rm
out}=\mathcal{U}\ket{\phi^{\mathrm{in}}}\bra{\phi^{\mathrm{in}}}\mathcal{U}^{\dagger}$.

The QAOA can be interpreted as an $\left(N+1\right)$-layer QNN featuring $m$
neurons per layer. We identify each operator pair $e^{-iAt_{l}}$,
$e^{-iB\tau_{l}}$ as the layer $l+1$ unitary acting on all $m$ neurons of
layer $l$. The resulting state is the input for the neurons of the next layer
$l+1$.

#### The Quantum Circuit

The QAOA’s quantum circuit is implemented using only $m$ qubits as each layer
is represented by the same set of qubits. The Hilbert space is the same as for
the DQNN but with lower dimension $2^{m}$. We initialize the $m$ qubits in a
given state $\ket{\phi^{\mathrm{in}}}$ with dimension $d=2^{m}$. $N$ is chosen
to be $d^{2}/2$ so that the QNN converges to an optimal solution [37]. Thus,
the number of total parameters equals $N_{p}=d^{2}=4^{m}$. An exemplary
quantum circuit for $m=2$ is depicted in Fig. 1c.

##  III Training the networks

In this section we describe the learning algorithm applied and present its
implementation.

###  III.1 Learning Algorithm

For both QNNs, the task is to learn an unknown unitary $V\in U(2^{m})$ from a
given training set
$\\{\ket{\phi^{\mathrm{in}}_{x}},\ket{\phi^{\mathrm{out}}_{x}}\\}^{N_{T}}_{x=1}$
where $\ket{\phi^{\mathrm{out}}_{x}}=V\ket{\phi^{\mathrm{in}}_{x}}$. As a
general measure for the network’s performance we evaluate the fidelity of the
desired output $\ket{\phi^{\mathrm{out}}_{x}}$ and the network’s output
$\rho^{\mathrm{out}}_{x}$. Averaging over all pairs $x$ in the training set
yields the training cost of the network:

$C_{T}=\frac{1}{N_{T}}\sum_{x=1}^{N_{T}}\langle\phi^{\text{out}}_{x}\rvert\rho_{x}^{\text{out}}\lvert\phi^{\text{out}}_{x}\rangle.$
(5)

The networks are trained iteratively by gradient descent. Both are implemented
as quantum circuits parameterized by $N_{p}$ independent parameters. The
parameters are initialized as $\vec{p}_{0}=(p_{1},...,p_{N_{p}})^{T}$. At each
epoch, all parameters are updated so that they (locally and infinitesimally)
maximize the training cost. The new parameters are given by
$\vec{p}_{t+1}=\vec{p}_{t}+\vec{dp}$. The update step is defined as
$\vec{dp}=\eta\vec{\nabla}C\left(\vec{p}_{t}\right)$ with the learning rate
$\eta$. The gradient of the training cost is approximated by:

$\nabla_{k}C\left(\vec{p}_{t}\right)=\frac{C\left(\vec{p}_{t}+\epsilon\vec{e}_{k}\right)-C\left(\vec{p}_{t}-\epsilon\vec{e}_{k}\right)}{2\epsilon}+\mathcal{O}\left(\epsilon^{2}\right)$
(6)

where $\vec{e}_{k}$ has components $e_{k}^{j}=\delta_{k}^{j}$,
$k,j=1,...,N_{p}$ and $\epsilon>0$. In the following, $\epsilon$ and $\eta$
are called the hyperparameters of our networks.

After training we evaluate the networks’ generalization via a validation set
$\\{\ket{\phi^{\mathrm{in}}_{x}},\ket{\phi^{\mathrm{out}}_{x}}\\}^{N_{V}}_{x=1}$
built in the same way as the training set. Analogously, the validation cost is
defined as:

$C_{V}=\frac{1}{N_{V}}\sum_{x=1}^{N_{V}}\langle\phi^{\text{out}}_{x}\rvert\rho_{x}^{\text{out}}\lvert\phi^{\text{out}}_{x}\rangle.$
(7)

###  III.2 Implementation

The execution of the QNNs involves three crucial steps.

i. Initialization: First, a set of training pairs as well as a set of
validation pairs, if not already given, are generated from a target unitary
$V\in U\left(d\right)$. The hyperparameters are set according to the problem
and network at hand. The parameters $\vec{p}_{0}$ are initialized randomly.

ii. Learning: The following steps are repeated for a given number of epochs.
The full quantum circuit (see Fig. 1a) consists of three main parts. In the
first part, a set of $m$ qubits is initialized in the state
$\ket{\phi^{\mathrm{out}}_{x}}$ and another $m$ qubits in
$\ket{\phi^{\mathrm{in}}_{x}}$. The remaining qubits, if necessary, are
initialized in $\ket{0}$. The second part features the network’s evaluation of
$\ket{\phi^{\mathrm{in}}_{x}}$. In the last part, the fidelity is calculated
using the destructive swap test [58, 59]. The full circuit is executed for all
states in the training set to calculate the training cost. The network
parameters are updated using gradient descent as described in section III.1.

iii. Validation: The network is evaluated using a validation set. Its states
are unknown to the network and uncorrelated to the training set. The resulting
validation cost yields a measure for the networks’ generalization
capabilities.

##  IV Results

In this section, we perform numerical studies of the previously described
networks. This includes an analysis of their generalization capabilities and
noise robustness. Additionally, we train both networks on real quantum
computers.

###  IV.1 Setup

To analyze and compare the two networks described in Section II, we choose a
target unitary of dimension $d=4$. Thus, both networks have $m=2$ input and
output qubits, respectively. We train a one-layer DQNN of the form  and a QAOA
network with $N=8$ layers. These shallow network architectures are well suited
for an analysis of both network types. They already exhibit the quantum
entanglement and implement the basic structure of QNNs. This enables a
generalization of the main results to more extensive networks. These networks
are implemented using 6 (4) qubits for the DQNN (QAOA), including the
initialization and measurement as described in Section III.2. Training these
networks requires the learning of 24 (16) parameters, respectively. Due to the
small number of parameters for both networks, we do not encounter the effects
of barren plateaus. For the DQNN, the parameters are initialized in the range
$\left[0,2\pi\right)$. Here, we found $\eta=0.5$ and $\epsilon=0.25$ as the
optimal hyperparameters. For the QAOA, we initialize the parameters in the
range $\left[-1,1\right]$ and found the hyperparameters $\eta=0.075$ and
$\epsilon=0.05$ optimal.

The implementation and execution of the corresponding quantum circuits was
carried out using the open-source SDK Qiskit [55] and the quantum devices
hosted by IBM [56]. Qiskit allows decomposition of the parameterized networks
mentioned in Section II to a predefined set of elementary gates yielding a
quantum circuit that the IBM quantum devices execute. While the number of
required basis gates for the initialization (6-12 single-qubit gates and 6
CNOT gates) and the fidelity measurement (2 single-qubit gates and 2 CNOT
gates) is independent of the network type, the required qubits for
implementing the core network circuit differs. For example, mapping the
network’s circuit to the H-topology of ibmq_casablanca [56] results in 57 (97)
single-qubit gates and 63 (57) CNOT gates for the DQNN (QAOA).

The training of the network was executed in a hybrid manner. At each epoch,
the cost was evaluated by the quantum execution, which was then used to update
the parameters classically. To guarantee the training’s success, it was
necessary to use a training set that was large enough to determine the
transformation of the target unitary. For a 2-2 network ($V\in
U\left(4\right)$), this was achieved using four training pairs [60].

DQNN:  Identity cost  Validation cost  Training cost QAOA:  Identity cost
Validation cost  Training cost

(a) Generalization Analysis. The  Noise Robust QNN ($m=2$ QAOA) using the
simulated ibmq_casablanca for $\epsilon=0.5$, $\eta=1.0$ ($\epsilon=0.15$,
$\eta=0.1$).

(b) Gate Noise Analysis. The  Noise Robust QNN ($m=2$ QAOA) using the qubit
coupling map of ibmq_16_melbourne for $\epsilon=0.25$, $\eta=0.5$
($\epsilon=0.05$, $\eta=0.05$).

Figure 2: Training on simulated devices. (a) shows the validation cost ( )
after training both networks with $N_{T}=1,\dots,4$ training pairs for 1000
epochs. The identity cost ( ) gives an estimate for the cost of an ideally
trained network. Although the networks use identical device simulations, the
DQNN generally reaches higher validation costs. In (b), the networks are
trained for varying gate noise until the validation cost convergences, whereby
the training cost ( ) is shown, additionally. Here, $k=1$ corresponds to the
gate noise of currently available NISQ devices. Especially in this region, the
DQNN performs better. In both analyses, the quantities are averaged over 20
(a) and 5 (b) training sessions with different target unitaries $V$ and start
parameters $\vec{p_{0}}$.

###  IV.2 Generalization Analysis

Due to the generally limited amount of quantum data, it is of paramount
interest to analyze the network’s generalization capabilities, i.e., how does
it perform on previously unseen data. We quantify this via a _validation cost_
defined by four validation pairs while training the network using only
$N_{T}=1,\dots,4$ training pairs. The validation cost represents a fair metric
to compare QNN architectures as it quantifies the influence of _overfitting_
where a QNN architecture maximises the training cost at the expense of
performance on unseen data.

We executed the quantum circuits on a simulator incorporating the real-time
noise of ibmq_casablanca, which we set constant for all values of $N_{T}$. The
training was repeated several times to average over different initial
parameters, target unitaries, and noise snapshots.

The results of this study are shown in Fig. 2(a). Alongside the validation
costs as a function of the number of training pairs, the networks’ _identity
costs_ are also shown. The identity cost is calculated using $V=\mathbbm{1}$
and corresponding parameters so that the respective network acts as the
identity. Each gate is still applied and adds noise to the circuit. Thus, the
identity cost provides an estimate for the best possible costs of an ideally
trained network.

Our studies show that both networks are capable of generalizing the available
information. As expected, the validation costs increase with the number of
training pairs. According to the higher identity cost, the DQNN also reaches
higher validation costs than the QAOA. Additionally, the DQNN generalizes with
higher reliability as its different training sessions for $N_{T}=4$ yield very
few outliers. In contrast, the QAOA’s validation cost is approximately
uniformly distributed around the mean.

###  IV.3 Gate Noise Analysis

The success of the DQNN and the QAOA is strongly affected by the noise of the
executing quantum device. The primary sources are readout noise and gate noise
[61]. Both networks are equally influenced by readout noise as they are
evaluated by the same measurement method. Our focus in this paper is on the
comparison of both networks and thus we neglect readout noise. The influence
of gate noise, however, does differ because the networks consist of different
gates. To test the influence of gate noise on both networks’ performances, we
trained the DQNN and the QAOA using a depolarizing quantum error channel [62].
It was parametrized by the depolarization probabilities
$\lambda^{\text{g}}=k\lambda^{\text{g}}_{0}$ with basis gates $g=\text{CNOT,
SX, RZ}$ and scaling factor $k$. The parameter $\lambda^{\text{g}}_{0}$ was
chosen to match the gate error probabilities of current NISQ devices. Here, we
chose $\lambda^{\text{CNOT}}_{0}=$3.14\text{\times}{10}^{-2}$$,
$\lambda^{\text{SX}}_{0}=$1.18\text{\times}{10}^{-3}$$,
$\lambda^{\text{RZ}}_{0}=0$, which is an approximation for ibmq_16_melbourne
[56]. We also used ibmq_16_melbourne’s qubit coupling map.

Fig. 2(b) shows the numerical results comparing the DQNN and the QAOA for
different error probability factors $k$. Note that $k=1$ corresponds to the
gate noise of currently available NISQ devices. For $k=0$, i.e., a noise-free
quantum device, both QNNs perform equally well. In the presence of gate noise,
however, the DQNN has a higher identity cost, which in each case also yields a
higher training and validation cost. This indicates that the DQNN is more
suitable for learning unitaries on NISQ devices than the QAOA.

(a) The  DQNN on ibmq_casablanca for $\epsilon=0.5$ and $\eta=1.0$.

(b) The $m=2$ QAOA on ibmq_casablanca for $\epsilon=0.15$ and $\eta=0.1$.

Figure 3: Training on quantum computers. This figure shows the relevant
quantities measured while training the DQNN (a) and the QAOA (b). Both
networks have been trained for $100$ epochs. Each epoch, the training cost ( )
is calculated via four $4$ training pairs. Every fifth epoch, the validation
cost ( ) is measured using $4$ validation pairs, as well as the identity cost
( ) using $4$ output training states.

###  IV.4 NISQ Device Execution

Apart from simulating the QNNs to study their main properties, we have to
execute them on actual NISQ devices to broaden our knowledge about their real-
world applications and benefit from their advantages. To demonstrate both the
challenges and the potential of training QNNs on NISQ devices, we present
results of a single training session, respectively. By this, we can evaluate
the direct effect of the real device noise on the different costs. We trained
both QNNs using the IBM 7-qubit device ibmq_casablanca [56].

The relevant costs during training the DQNN and the QAOA to learn an unknown
unitary $V\in U(d)$ are shown in Fig. 3. In the noise-free case, the training
cost should always be monotone increasing for well-chosen hyperparameters.
Here, the variance in the training cost indicates the networks’ response to
gate and measurement noise. However, the training and validation costs seem to
be correlated to the varying identity cost. That indicates that the variance
of the identity cost is not only a statistical error but arises from a noise
drift of the quantum device itself. In the previous analyses, the identity
cost served as the upper limit for the training and validation cost. Here, the
training cost exceeds the identity cost after a few epochs. This indicates the
networks’ surprising ability to factor in the noise circumstances of the real
device. Having noted this, the high validation to identity cost ratio
demonstrates the remarkable capability of both networks to generalize the
provided information despite the high noise levels.

##  V Discussion and Outlook

In this paper we introduced a dissipative Quantum Neural Network ansatz and
compared it to the Quantum Approximate Optimization Algorithm. Both QNNs were
implemented and trained on IBM’s quantum computers.

It was found that a DQNN learns an unknown unitary better than the QAOA, as
quantified by the validation cost. Our analysis demonstrates that the DQNN
generalizes with higher reliability and accuracy than the QAOA. Moreover, we
found that the DQNN is less susceptible to gate noise than the QAOA, most
notably in the region of current NISQ device noise levels. We demonstrated the
ability of both networks and the gradient descent-based learning algorithm to
withstand the noise of today’s quantum devices. However, it should be noted
that noise still prevents QNNs from reaching high fidelities.

Besides the reduction of noise, the further development of quantum devices
holds potential in providing resettable qubits. This would reduce the number
of qubits required to operate a DQNN and thus allow the exploration of
multiple layers. It is a fascinating problem whether DQNN for higher-
dimensional unitaries and non-unitary maps offer similar advantages. We leave
this question to future work.

The code is available at
https://github.com/qigitphannover/DeepQuantumNeuralNetworks.

###### Acknowledgements.

Helpful discussions with Dmytro Bondarenko, Terry Farrelly, Polina Feldmann,
Alexander Hahn, Jan Hendrik Pfau, Robert Salzmann, Daniel Scheiermann,
Viktoria Schmiesing, Marvin Schwiering, and Ramona Wolf are gratefully
acknowledged. This work was supported, in part, by the Quantum Valley Lower
Saxony (QVLS), the DFG through SFB 1227 (DQ-mat), the RTG 1991, and funded by
the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under
Germany’s Excellence Strategy EXC-2123 QuantumFrontiers 390837967. We
acknowledge the use of IBM Quantum services for this work. The views expressed
are those of the authors, and do not reflect the official policy or position
of IBM or the IBM Quantum team.

## References

  * Feynman [1982] R. P. Feynman, Int. J. Theor. Phys 21 (1982).
  * Ciliberto  _et al._ [2018] C. Ciliberto, M. Herbster, A. D. Ialongo, M. Pontil, A. Rocchetto, S. Severini, and L. Wossnig, Proc. R. Soc. A 474, 20170551 (2018).
  * Dunjko and Briegel [2018] V. Dunjko and H. J. Briegel, Rep. Prog. Phys. 81, 074001 (2018).
  * Cerezo  _et al._ [2020a] M. Cerezo, A. Arrasmith, R. Babbush, S. C. Benjamin, S. Endo, K. Fujii, J. R. McClean, K. Mitarai, X. Yuan, L. Cincio, _et al._ , (2020a), arXiv:2012.09265 .
  * Kouda  _et al._ [2005] N. Kouda, N. Matsui, H. Nishimura, and F. Peper, Neural Comput & Applic 14, 114 (2005).
  * Bu  _et al._ [2021] K. Bu, D. E. Koh, L. Li, Q. Luo, and Y. Zhang, (2021), arXiv:2101.06154 .
  * Benedetti  _et al._ [2019] M. Benedetti, E. Lloyd, S. Sack, and M. Fiorentini, Quantum Sci. Technol. 4, 043001 (2019).
  * Mitarai  _et al._ [2018] K. Mitarai, M. Negoro, M. Kitagawa, and K. Fujii, Phys. Rev. A 98, 032309 (2018).
  * Du  _et al._ [2018] Y. Du, M.-H. Hsieh, T. Liu, and D. Tao, (2018), arXiv:1810.11922 .
  * Stokes  _et al._ [2020] J. Stokes, J. Izaac, N. Killoran, and G. Carleo, Quantum 4, 269 (2020).
  * Schuld  _et al._ [2019] M. Schuld, V. Bergholm, C. Gogolin, J. Izaac, and N. Killoran, Phys. Rev. A 99, 032331 (2019).
  * Ostaszewski  _et al._ [2019] M. Ostaszewski, E. Grant, and M. Benedetti, arXiv:1905.09692 (2019), arXiv:1905.09692 .
  * Beer  _et al._ [2020] K. Beer, D. Bondarenko, T. Farrelly, T. J. Osborne, R. Salzmann, D. Scheiermann, and R. Wolf, Nat commun 11, 1 (2020).
  * Schuld  _et al._ [2020] M. Schuld, A. Bocharov, K. M. Svore, and N. Wiebe, Phys. Rev. A 101, 032308 (2020).
  * Zhang  _et al._ [2020] K. Zhang, M.-H. Hsieh, L. Liu, and D. Tao, (2020), arXiv:2011.06258 .
  * Tacchino  _et al._ [2020] F. Tacchino, P. Barkoutsos, C. Macchiavello, I. Tavernelli, D. Gerace, and D. Bajoni, Quantum Sci. Technol. 5, 044010 (2020).
  * Sharma  _et al._ [2020] K. Sharma, M. Cerezo, L. Cincio, and P. J. Coles, (2020), arXiv:2005.12458 .
  * Skolik  _et al._ [2020] A. Skolik, J. R. McClean, M. Mohseni, P. van der Smagt, and M. Leib, (2020), arXiv:2006.14904 .
  * Torrontegui and García-Ripoll [2019] E. Torrontegui and J. J. García-Ripoll, EPL 125, 30004 (2019).
  * Killoran  _et al._ [2019] N. Killoran, T. R. Bromley, J. M. Arrazola, M. Schuld, N. Quesada, and S. Lloyd, Phys. Rev. Research 1, 033063 (2019).
  * Steinbrecher  _et al._ [2019] G. R. Steinbrecher, J. P. Olson, D. Englund, and J. Carolan, npj Quantum Inf 5, 1 (2019).
  * Farhi and Neven [2018] E. Farhi and H. Neven, (2018), arXiv:1802.06002 .
  * Cao  _et al._ [2017] Y. Cao, G. G. Guerreschi, and A. Aspuru-Guzik, (2017), arXiv:1711.11240 .
  * Wan  _et al._ [2017] K. H. Wan, O. Dahlsten, H. Kristjánsson, R. Gardner, and M. Kim, npj Quantum Inf 3, 1 (2017).
  * da Silva  _et al._ [2016] A. J. da Silva, T. B. Ludermir, and W. R. de Oliveira, Neural Networks 76, 55 (2016).
  * Schuld  _et al._ [2015] M. Schuld, I. Sinayskiy, and F. Petruccione, Physics Letters A 379, 660 (2015).
  * Altaisky [2001] M. Altaisky, (2001), arXiv:quant-ph/0107012 .
  * Lewenstein [1994] M. Lewenstein, Journal of Modern Optics 41, 2491 (1994).
  * Geller  _et al._ [2021] M. R. Geller, Z. Holmes, P. J. Coles, and A. Sornborger, (2021), arXiv:2104.03295 .
  * Schuld and Killoran [2019] M. Schuld and N. Killoran, Phys. Rev. Lett. 122, 040504 (2019).
  * Bondarenko and Feldmann [2020] D. Bondarenko and P. Feldmann, Phys. Rev. Lett. 124, 130502 (2020).
  * Achache  _et al._ [2020] T. Achache, L. Horesh, and J. Smolin, (2020), arXiv:2012.14714 .
  * Note [1] Note that, contrary to what the name perhaps suggests, DQNN are universal for quantum computation and can equally simulate both unitary and dissipative quantum processes.
  * Farhi  _et al._ [2014] E. Farhi, J. Goldstone, and S. Gutmann, (2014), arXiv:1411.4028 .
  * Farhi and Harrow [2016] E. Farhi and A. W. Harrow, (2016), arXiv:1602.07674 .
  * Hadfield  _et al._ [2019] S. Hadfield, Z. Wang, B. O’Gorman, E. G. Rieffel, D. Venturelli, and R. Biswas, Algorithms 12, 34 (2019).
  * Kiani  _et al._ [2020] B. T. Kiani, S. Lloyd, and R. Maity, (2020), arXiv:2001.11897 .
  * Streif and Leib [2019] M. Streif and M. Leib, (2019), arXiv:1901.01903 .
  * Wang  _et al._ [2018] Z. Wang, S. Hadfield, Z. Jiang, and E. G. Rieffel, Phys. Rev. A 97, 022304 (2018).
  * Wecker  _et al._ [2016] D. Wecker, M. B. Hastings, and M. Troyer, Phys. Rev. A 94, 022309 (2016).
  * Maciejewski  _et al._ [2021] F. B. Maciejewski, F. Baccari, Z. Zimborás, and M. Oszmaniec, (2021), arXiv:2101.02331 .
  * Otterbach  _et al._ [2017] J. Otterbach, R. Manenti, N. Alidoust, A. Bestwick, M. Block, B. Bloom, S. Caldwell, N. Didier, E. S. Fried, S. Hong, _et al._ , (2017), arXiv:1712.05771 .
  * Lechner [2020] W. Lechner, IEEE Transactions on Quantum Engineering 1, 1 (2020).
  * Farhi  _et al._ [2015] E. Farhi, J. Goldstone, and S. Gutmann, (2015), arXiv:1412.6062 .
  * Farhi  _et al._ [2017] E. Farhi, J. Goldstone, S. Gutmann, and H. Neven, (2017), arXiv:1703.06199 .
  * Lin and Zhu [2016] C. Y.-Y. Lin and Y. Zhu, (2016), arXiv:1601.01744 .
  * Preskill [2018] J. Preskill, Quantum 2, 79 (2018).
  * Biamonte  _et al._ [2017] J. Biamonte, P. Wittek, N. Pancotti, P. Rebentrost, N. Wiebe, and S. Lloyd, Nature 549, 195 (2017).
  * Wang  _et al._ [2020] S. Wang, E. Fontana, M. Cerezo, K. Sharma, A. Sone, L. Cincio, and P. J. Coles, (2020), arXiv:2007.14384 .
  * Cerezo  _et al._ [2020b] M. Cerezo, A. Sone, T. Volkoff, L. Cincio, and P. J. Coles, (2020b), arXiv:2001.00550 .
  * Grant  _et al._ [2019] E. Grant, L. Wossnig, M. Ostaszewski, and M. Benedetti, Quantum 3, 214 (2019).
  * McClean  _et al._ [2018] J. R. McClean, S. Boixo, V. N. Smelyanskiy, R. Babbush, and H. Neven, Nature Commun 9, 1 (2018).
  * Alam  _et al._ [2019] M. Alam, A. Ash-Saki, and S. Ghosh, (2019), arXiv:1907.09631 .
  * Xue  _et al._ [2019] C. Xue, Z.-Y. Chen, Y.-C. Wu, and G.-P. Guo, (2019), arXiv:1909.02196 .
  * Abraham  _et al._ [2019] H. Abraham _et al._ , Qiskit: An open-source framework for quantum computing (2019).
  * IBM Quantum team [2021] IBM Quantum team, IBM Quantum Experience, https://quantum-computing.ibm.com (2021).
  * Crooks [2019] G. E. Crooks, (2019), arXiv:1905.13311 .
  * Cincio  _et al._ [2018] L. Cincio, Y. Subaşı, A. T. Sornborger, and P. J. Coles, New J. Phys. 20, 113022 (2018).
  * Garcia-Escartin and Chamorro-Posada [2013] J. C. Garcia-Escartin and P. Chamorro-Posada, Phys. Rev. A 87, 052330 (2013).
  * Poland  _et al._ [2020] K. Poland, K. Beer, and T. J. Osborne, (2020), arXiv:2003.14103 .
  * Nachman  _et al._ [2020] B. Nachman, M. Urbanek, W. A. de Jong, and C. W. Bauer, npj Quantum Information 6, 1 (2020).
  * Nielsen and Chuang [2002] M. A. Nielsen and I. Chuang, American Journal of Physics 70, 558 (2002).