{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition\n", "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Overview\n", "\n", "Retrieving ground state information of a Hamiltonian is amongst the essential questions in physics and chemistry. Currently, it is widely believed that quantum computers are advantageous in solving this kind of problem. As one of the promising algorithms to demonstrate quantum supremacy in the near term, [Variational Quantum Eigensolver (VQE)](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)\n", "enables the study of quantum chemistry on Noisy Intermediate-Scale Quantum (NISQ) devices. However, various technical limitations still exist on current NISQ hardware, forbidding the deployment of large-scale quantum algorithms. For example, limited by the number of available qubits, researchers have not been able to simulate realistic large molecules with high precision. To overcome this barrier, researchers have proposed a wide range of distributed strategies [1-3]. In this tutorial, we take the distributed VQE based on Schmidt decomposition, proposed in [4], as an example to demonstrate how to implement distributed quantum algorithms using Paddle Quantum." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Schmidt Decomposition\n", "We start with the following trivial decomposition for any pure state $|\\psi\\rangle$ of a composite system $AB$:\n", "\n", "$$\n", "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n", "\\tag{1}\n", "$$\n", "\n", "where $|i\\rangle$ and $|j\\rangle$ are computational bases of subsystems $A$ and $B$ respectively, and $a_{ij}$ are elements of some complex matrix $a$. Then, we apply [singular value decomposition (SVD)](https://en.wikipedia.org/wiki/Singular_value_decomposition)\n", "on $a$, i.e., $a = udv$ with $u,v$ being unitary and $d$ diagonal. Hence, $a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$. \n", "\n", "By defining\n", "\n", "$$\n", "\\begin{aligned}\n", "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n", "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n", "\\lambda_k\\equiv & d_{kk},\n", "\\end{aligned}\n", "\\tag{2}\n", "$$\n", "\n", "we may rewrite Eq. (1) as\n", "\n", "$$\n", "\\begin{aligned}\n", " |\\psi\\rangle &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n", " &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n", " &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n", " &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n", "\\end{aligned}\n", "\\tag{3}\n", "$$\n", "\n", "The decomposition of $|\\psi\\rangle$ into the form of $\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ is known as its ***Schmidt decomposition*** [5], with $\\{\\lambda_k\\}_k$ called the *Schmidt coefficients* and the number of non-zero $\\lambda_k$'s its *Schmidt rank*. In fact, the property of SVD also guarantees that $\\lambda_k\\in\\mathbb{R}^+$ and $\\sum_k\\lambda_k^2=1$. " ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Distributed VQE Based on Schmidt Decomposition\n", "\n", "As a variation of the standard VQE [6], the distributed VQE also seeks to solve the ground state and its energy of an $N$-qubit Hamiltonian $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$， where $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ are Hamiltonian terms on subsystems $A,B$ respectively (we have assumed that $A$, $B$ both have $N/2$ qubits).\n", "\n", "To start with, we write the trial wave function as\n", "\n", "$$\n", "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big),\n", "\\tag{4}\n", "$$\n", "\n", "for some $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$ and $1\\leq S\\leq 2^{N/2}$ a user-defined constant. According to Schmidt decomposition, the target ground state also has the form of Eq. (4) and hence can be approximated with high precision by choosing appropriate parameters $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$.\n", "\n", "Now, for all $i,j=1,...,S$, we evaluate the following terms on an $N/2$-qubit quantum computer:\n", "\n", "$$\n", "\\begin{aligned}\n", "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n", "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n", "\\end{aligned}\n", "\\tag{5}\n", "$$\n", "\n", "Then, on a classical computer, we construct an $S\\times S$ dimensional matrix $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ according to\n", "\n", "$$\n", "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n", "\\tag{6}\n", "$$\n", "\n", "In this way, the target ground state energy can be written as \n", "$$\n", "\\begin{aligned}\n", "E_{tar} &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n", " &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n", " &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n", "\\end{aligned}\n", "\\tag{7}\n", "$$\n", "\n", "where $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$. By linear algebra, we see that $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ is exactly the minimal eigenvalue of $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$, which can be solved using classical algorithms.\n", "\n", "Finally, we repeat the whole process and minimize $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ to approximate $E_{tar}$ using gradient-based optimization methods." ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Paddle Quantum implementation\n", "\n", "First of all, we import necessary packages. Please make sure that you have *PaddlePaddle* >= 2.2.0 and *Paddle Quantum* >= 2.2.0, as we will use some of their latest features." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import time\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "\n", "import paddle\n", "import paddle_quantum\n", "from paddle_quantum.ansatz import Circuit\n", "from paddle_quantum.hamiltonian import Hamiltonian\n", "from paddle_quantum.loss import ExpecVal\n", "from paddle_quantum.state import State\n", "from paddle_quantum.qinfo import pauli_str_to_matrix, schmidt_decompose\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define some global constants:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "N = 10 # Number of qubits\n", "SEED = 16 # Fix a random seed\n", "ITR = 100 # Set the number of learning iterations\n", "LR = 0.1 # Set the learning rate\n", "D = 3 # Set the depth for QNN" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following function classically calculates the ground state information (the energy and the Schmidt rank of the ground state) of a Hamiltonian $H$, which we will use as the ground truth to benchmark our quantum models." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def get_ground_state_info(H):\n", "\n", " # Calculate the eigenvalues and eigenvectors of H\n", " vals, vecs = paddle.linalg.eigh(H)\n", " # Retrieve the ground state\n", " ground_state = paddle_quantum.State(vecs[:, 0])\n", " # Retrieve the ground state energy\n", " ground_state_energy = vals.tolist()[0]\n", " print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n", " # Run Schmidt decomposition on the ground state.\n", " l, _, _ = schmidt_decompose(ground_state)\n", " print(f'Schmidt rank of the ground state is {l.size}.')\n", "\n", " return ground_state_energy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we generate a Hamiltonian and calculate its ground state information." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The ground state energy is -0.99783 Ha.\n", "Schmidt rank of the ground state is 32.\n" ] } ], "source": [ "# Fix a random seed\n", "np.random.seed(SEED)\n", "\n", "# Hard code a random a Hamiltonian\n", "coefs = [-0.8886258, 0.453882]\n", "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n", "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4'] # pauli substring for system A\n", "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4'] # pauli substring for system B\n", "\n", "# Convert relavent object into Tensor form\n", "H = Hamiltonian(list(zip(coefs, pauli_str)))\n", "H_mtr = paddle.to_tensor(H.construct_h_matrix())\n", "coefs = paddle.to_tensor(coefs)\n", "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n", "H_A = paddle.to_tensor(np.stack(H_A))\n", "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n", "H_B = paddle.to_tensor(np.stack(H_B))\n", "\n", "# calculate the ground state information\n", "ground_state_energy = get_ground_state_info(H_mtr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have prepared a Hamiltonian, we may build a distributed VQE to solve it." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Construct parameterized circuit\n", "def U_cir(N, D):\n", " \n", " cir = Circuit(N) # Initialize an N-qubit-width circuit\n", " cir.complex_entangled_layer('full', N, D) # Add quantum gates\n", " return cir \n", "\n", "# Apply a parameterized circuit on the conputational bases\n", "# and return a tensor of shape [2**N, num_states]\n", "def output_states(num_states, N, cir):\n", " # Create num_states-many computational bases\n", " basis = paddle.eye(2**N, num_states)\n", " \n", " # Acquire a matrix of the parameterized circuit\n", " U = cir.unitary_matrix()\n", " \n", " # Apply the parameterized circuit on these bases\n", " vec = U @ basis \n", " \n", " return vec" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code below is core to this tutorial. Please compare them with the formulae given in the beginning section and make sure that they are well understood." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Construct the distributed model\n", "class DistributedVQE(paddle.nn.Layer):\n", " def __init__(self, N, D, S):\n", " super().__init__()\n", " paddle.seed(SEED)\n", "\n", " self.S = S # Define constant S\n", " self.N = N\n", " self.cir = [U_cir(N//2, D), U_cir(N - N//2, D)]\n", " \n", " # The core logic of distributed VQE\n", " def forward(self):\n", " # Obtain U|k> and V|k> for subsystems A and B respectively \n", " vec_A = output_states(self.S, self.N//2, self.cir[0])\n", " vec_B = output_states(self.S, self.N - self.N//2, self.cir[1])\n", " \n", " # Calculate tensor E_A, E_B, which have elements E_{ijt}^A and E_{ijt}^B, as per defined in above\n", " E_A = vec_A.conj().t() @ H_A @ vec_A\n", " E_B = vec_B.conj().t() @ H_B @ vec_B\n", " M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n", "\n", " # Find the minimal eigenvalue of M\n", " eigval = paddle.linalg.eigvalsh(M)\n", " loss = eigval[0]\n", " \n", " return loss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define training function." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def train(model):\n", " start_time = time.time() # To calculate the running time of this function\n", " params = sum([cir.parameters() for cir in model.cir], [])\n", " # We will use Adam, a gradient-based optimizer to optimize theta and phi\n", " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", " summary_loss = [] # Save loss history\n", "\n", " # Optimization iteration\n", " for itr in range(ITR):\n", " # Forward propagation to calculates the loss function\n", " loss = model()\n", " # Backward propagation to optimize the loss function\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # Update optimization result\n", " summary_loss.append(loss.numpy())\n", " # Print itermediary result\n", " if (itr+1) % 20 == 0:\n", " print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n", "\n", " print(f'Ground truth is {ground_state_energy:.4f} Ha')\n", " print(f'Training took {time.time() - start_time:.2f}s')\n", " \n", " plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n", " plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':', label='ground truth')\n", " plt.legend()\n", " plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we are ready to instantiate the model and train it!" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter: 20, loss: -0.9244 Ha\n", "iter: 40, loss: -0.9906 Ha\n", "iter: 60, loss: -0.9968 Ha\n", "iter: 80, loss: -0.9977 Ha\n", "iter: 100, loss: -0.9978 Ha\n", "Ground truth is -0.9978 Ha\n", "Training took 7.24s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Note that we manually set S = 4 as the Hamiltonian we just created interacts weakly across the subsystems.\n", "# (See the Conclusion section for further description)\n", "vqe = DistributedVQE(N, D, S=4)\n", "train(vqe)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have plotted the actual ground state energy as a dotted line in the figure above. We see that the loss curve converges to the dotted line, meaning that our distributed VQE successfully found the ground state energy of the Hamiltonian. However, to properly evaluate our model, we need to compare it with the standard VQE, which we build below:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "class StandardVQE(paddle.nn.Layer):\n", " def __init__(self, N, D, S):\n", " super().__init__()\n", " paddle.seed(SEED)\n", " self.cir = U_cir(N, D)\n", " self.loss_fcn = ExpecVal(H)\n", " \n", " def forward(self):\n", " output_state = self.cir()\n", " loss = self.loss_fcn(output_state)\n", " return loss.cast('float64').flatten()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instantiate and train the StandardVQE." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter: 20, loss: -0.8365 Ha\n", "iter: 40, loss: -0.9852 Ha\n", "iter: 60, loss: -0.9958 Ha\n", "iter: 80, loss: -0.9975 Ha\n", "iter: 100, loss: -0.9978 Ha\n", "Ground truth is -0.9978 Ha\n", "Training took 1278.13s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "svqe = StandardVQE(N, D, S=1)\n", "train(svqe) # Train the standard VQE " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Interestingly, in a distributed model, we only need to simulate two $N/2$-qubit unitary transformations, which is, of course, much more time- and space-efficient than simulating an $N$-qubit unitary transformation in the standard VQE." ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Conclusion\n", "\n", "In this tutorial, we built a distributed VQE and demonstrated some of its advantages:\n", "- The capability of NISQ devices is expanded. Distributed strategies enable the deployment of quantum algorithms which require qubits that exceed the capability of current hardware.\n", "- The computation efficiency is improved. For classical simulation of quantum processes, distributed algorithms reduce the dimension of unitary matrices, hence reducing the space and time cost for simulating them.\n", "\n", "In the meantime, one must note that $S$, as a user-defined constant, plays a key role in the training accuracy and efficiency:\n", "- For Hamiltonians which encode weak inter-subsystem interactions, their ground states are weakly entangled across the subsystems [7]. Hence, the Schmidt ranks are small and can be accurately and efficiently simulated by a small $S$. In fact, our example and most physically and chemically interesting Hamiltonians fall into this category.\n", "- In contrast, for Hamiltonians which encode strong inter-subsystem interactions, their ground states are strongly entangled. Hence, a large $S$ may be required. But anyway, $S$ is upper-bounded by $2^{N/2}$ and thus the dimension of $M$ is upper-bounded by $2^{N/2}\\times2^{N/2}$, which is still much smaller than the dimension of the initial Hamiltonian ($2^{N}\\times 2^{N}$). Consequently, the efficiency of this algorithm is always better than the purely classical simulation." ] }, { "cell_type": "markdown", "metadata": { "jp-MarkdownHeadingCollapsed": true, "tags": [] }, "source": [ "_______\n", "\n", "# References\n", "\n", "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n", "\n", "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619(2021)](https://arxiv.org/abs/2106.07619).\n", "\n", "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n", "\n", "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n", "\n", "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n", "\n", "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n", "\n", "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)." ] } ], "metadata": { "interpreter": { "hash": "9043b12ec77a531919bc05f05830335d23baf822720cbea14b03018197d26545" }, "kernelspec": { "display_name": "Python 3.8.0 ('paddle-quantum-dev')", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.0" } }, "nbformat": 4, "nbformat_minor": 5 }