1,414 research outputs found
Differentiable Programming Tensor Networks
Differentiable programming is a fresh programming paradigm which composes
parameterized algorithmic components and trains them using automatic
differentiation (AD). The concept emerges from deep learning but is not only
limited to training neural networks. We present theory and practice of
programming tensor network algorithms in a fully differentiable way. By
formulating the tensor network algorithm as a computation graph, one can
compute higher order derivatives of the program accurately and efficiently
using AD. We present essential techniques to differentiate through the tensor
networks contractions, including stable AD for tensor decomposition and
efficient backpropagation through fixed point iterations. As a demonstration,
we compute the specific heat of the Ising model directly by taking the second
order derivative of the free energy obtained in the tensor renormalization
group calculation. Next, we perform gradient based variational optimization of
infinite projected entangled pair states for quantum antiferromagnetic
Heisenberg model and obtain start-of-the-art variational energy and
magnetization with moderate efforts. Differentiable programming removes
laborious human efforts in deriving and implementing analytical gradients for
tensor network programs, which opens the door to more innovations in tensor
network algorithms and applications.Comment: Typos corrected, discussion and refs added; revised version accepted
for publication in PRX. Source code available at
https://github.com/wangleiphy/tensorgra
Programming Quantum Computers Using Design Automation
Recent developments in quantum hardware indicate that systems featuring more
than 50 physical qubits are within reach. At this scale, classical simulation
will no longer be feasible and there is a possibility that such quantum devices
may outperform even classical supercomputers at certain tasks. With the rapid
growth of qubit numbers and coherence times comes the increasingly difficult
challenge of quantum program compilation. This entails the translation of a
high-level description of a quantum algorithm to hardware-specific low-level
operations which can be carried out by the quantum device. Some parts of the
calculation may still be performed manually due to the lack of efficient
methods. This, in turn, may lead to a design gap, which will prevent the
programming of a quantum computer. In this paper, we discuss the challenges in
fully-automatic quantum compilation. We motivate directions for future research
to tackle these challenges. Yet, with the algorithms and approaches that exist
today, we demonstrate how to automatically perform the quantum programming flow
from algorithm to a physical quantum computer for a simple algorithmic
benchmark, namely the hidden shift problem. We present and use two tool flows
which invoke RevKit. One which is based on ProjectQ and which targets the IBM
Quantum Experience or a local simulator, and one which is based on Microsoft's
quantum programming language Q.Comment: 10 pages, 10 figures. To appear in: Proceedings of Design, Automation
and Test in Europe (DATE 2018
Learning a quantum computer's capability using convolutional neural networks
The computational power of contemporary quantum processors is limited by
hardware errors that cause computations to fail. In principle, each quantum
processor's computational capabilities can be described with a capability
function that quantifies how well a processor can run each possible quantum
circuit (i.e., program), as a map from circuits to the processor's success
rates on those circuits. However, capability functions are typically unknown
and challenging to model, as the particular errors afflicting a specific
quantum processor are a priori unknown and difficult to completely
characterize. In this work, we investigate using artificial neural networks to
learn an approximation to a processor's capability function. We explore how to
define the capability function, and we explain how data for training neural
networks can be efficiently obtained for a capability function defined using
process fidelity. We then investigate using convolutional neural networks to
model a quantum computer's capability. Using simulations, we show that
convolutional neural networks can accurately model a processor's capability
when that processor experiences gate-dependent, time-dependent, and
context-dependent stochastic errors. We then discuss some challenges to
creating useful neural network capability models for experimental processors,
such as generalizing beyond training distributions and modelling the effects of
coherent errors. Lastly, we apply our neural networks to model the capabilities
of cloud-access quantum computing systems, obtaining moderate prediction
accuracy (average absolute error around 2-5%)
A parallel functional language compiler for message-passing multicomputers
The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's 7r-calculus which achieves asynchronous communication. We present the first working implementation of this scheme on distributed-memory message-passing multicomputers with split-phase transactions. Simulated assessment of the generated parallel code indicates good parallel behaviour. Parallelism is introduced using explicit, advisory user annotations in the source' program and there are two major aspects of the use of annotations in the compiler. First, the front end of the compiler is parallelised so as to improve its efficiency at compilation time when it is compiling input programs. Secondly, the input programs to the compiler can themselves contain annotations based on which the compiler generates the multi-threaded parallel code. These, therefore, make Naira, unusually and uniquely, both a parallel and a parallelising compiler. We adopt a medium-grained approach to granularity where function applications form the unit of parallelism and load distribution. We have experimented with two different task distribution strategies, deterministic and random, and have also experimented with thread-based and quantum- based scheduling policies. Our experiments show that there is little efficiency difference for regular programs but the quantum-based scheduler is the best in programs with irregular parallelism. The compiler has been successfully built, parallelised and assessed using both idealised and realistic measurement tools: we obtained significant compilation speed-ups on a variety of simulated parallel architectures. The simulated results are supported by the best results obtained on real hardware for such a large program: we measured an absolute speedup of 2.5 on a network of 5 SUN workstations. The compiler has also been shown to have good parallelising potential, based on popular test programs. Results of assessing Naira's generated unoptimised parallel code are comparable to those produced by other successful parallel implementation projects
Towards Practical Hybrid Quantum / Classical Computing
Quantum computing is in a critical phase where theoretical schemes and protocols are now being implemented in the real world for the first time. Experimental implementations can help us solidify ideas, and can also complicate them. In the case of quantum communication protocols, we present the first experimental implementations of two entanglement-based schemes using IBM’s superconducting transmon qubit based technology. We find that the schemes are experimentally feasible with current technology, and give an idea of how much room for improvement there is before quantum technology can meet the highest theoretical expectations. These communication schemes may be fundamental components of the future quantum internet. We also present an overview of the emerging field of quantum blockchain protocols that could form a part of the quantum / classical communication structures of the future. Interaction between classical and quantum technologies can impair purely quantum designs, but can also be harnessed to enhance hybrid quantum / classical approaches. Finally, we suggest a path towards the hybridization of arbitrary code execution and verification in the hybrid quantum / classical networks of the future
- …