{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Frequently Used Functions in Paddle Quantum\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this file, we list some frequently used functions in Paddle Quantum.\n", "\n", "You can see other functions in [API](https://qml.baidu.com/api/introduction.html)\n", "\n", "Here we will also use preparing a pure state as an example to see how to use Paddle Quantum to realize quantum neural network algorithms." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Import Mudules " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# 1.1 Import numpy and paddle\n", "import numpy as np\n", "import paddle\n", "\n", "# 1.2 Create quantum circuit\n", "from paddle_quantum.circuit import UAnsatz \n", "\n", "# 1.3 Create quantum state - in np.ndarray form\n", "from paddle_quantum.state import vec, vec_random # As vector\n", "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational # As matrix\n", "\n", "# 1.4 Create Matrix - in np.ndarray form\n", "from scipy.stats import unitary_group # Random U matrix\n", "from paddle_quantum.utils import pauli_str_to_matrix # Pauli matrices for n qubits\n", "\n", "# 1.5 Matrix calculation with paddle.Tensor\n", "from paddle import matmul, trace # Calculate the inner product and trace\n", "from paddle_quantum.utils import dagger # Get dagger of a paddle.Tensor (note: for numpy.ndarray, you can use “.conj().T” to do dagger)\n", "\n", "# 1.6 Plot figure\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Often Used Parameters" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# 2.1 Parameters for quantum circuit\n", "\n", "N = 3 # Qubits number in Quantum circuit\n", "DEPTH = 2 # Depth of the quantum circuit (Layers number)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# 2.2 Parameters in the iteration \n", "\n", "ITR = 200 # Iteration number \n", "LR = 0.2 # Learning rate \n", "SEED = 1 # Random seed \n", "paddle.seed(SEED) # seed for paddle\n", "np.random.seed(SEED) # seed for numpy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Numpy Matrix" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# 3.1 Random unitary gate\n", "V = unitary_group.rvs(2) # Random 2*2 V" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# 3.2 Diagonal matrix\n", "D = np.diag([0.2, 0.8])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# 3.3 Transpose complex conjugate\n", "V_dagger = V.conj().T" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# 3.4 Matrix multiplication: @\n", "H = (V @ D @ V_dagger)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.9999999999999998-8.239936510889834e-18j)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3.5 Trace\n", "H.trace()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.2, 0.8])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3.6 Eigenvalues\n", "np.linalg.eigh(H)[0]" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# 3.7 Tensor product: A \\otimes B\n", "A = np.eye(2)\n", "B = H\n", "T = np.kron(A, B)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Note: in Paddle Quantum, you can use string to create matrix for Pauli matices with $n$ qubit." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# An example: 0.4*I⊗Z+0.4*Z⊗I+0.2*X⊗X\n", "# In the string form: 0.4*kron(I, Z) + 0.4*kron(Z, I) + 0.2*kron(X, X)\n", "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", "H_matrix = pauli_str_to_matrix(H_info, 3) # pauli matices with 3 qubits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Quantum States" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# 4.1 Get pure states (a row vector in np.ndarray form)\n", "\n", "initial_state_pure1 = vec(0, N) # Get |00…0>, 2**N dimension row vector\n", "initial_state_pure2 = vec_random(N) # Get random pure state, row vector" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# 4.2 Get mixed states (in np.ndarray form)\n", "\n", "initial_state_mixed1 = density_op(N) # Get |00…0><00…0|\n", "# Get a random density matrix, can decide real or complex and its rank (rank = 1 means pure) \n", "initial_state_mixed2 = density_op_random(N, real_or_complex=2, rank=4)\n", "initial_state_mixed3 = completely_mixed_computational(N) # Get a maximally mixed state " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Quantum Circuit" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# 5.1 Create an N qubits quantum circuit\n", "cir = UAnsatz(N)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# 5.2 Add gates to the circuit - see Section 7\n", "# An example: add a CNOT gate to the first two qubits:\n", "cir.cnot([0, 1])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# 5.3 The output state of the circuit\n", "# The output state of the circuit as a vector in paddle.Tensor form.\n", "# Note: the shape of the output here is not a vector. It can be changed to a column vector \n", " # via function \"paddle.reshape(final_state, [2**N, 1]) —— it will be made better in the next version\n", "\n", "# Initial state is |00...0>\n", "final_state = cir.run_state_vector()\n", "# Initial state is not |00...0>\n", "initial_state_pure = paddle.to_tensor(initial_state_pure2)\n", "final_state_pure = cir.run_state_vector(initial_state_pure)\n", "# Change to np.array form\n", "final_state_pure_np = cir.run_state_vector().reshape([2**N, 1]).numpy()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# Initial state is |00…0><00…0|\n", "cir.run_density_matrix()\n", "# Initial state is not |00...0><00...0|\n", "initial_state_mixed = paddle.to_tensor(initial_state_mixed2)\n", "final_state_mixed = cir.run_density_matrix(initial_state_mixed)\n", "# Change to np.ndarray form\n", "final_state_mixed_np = cir.run_density_matrix().numpy()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 1., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 1., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 1., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 1., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 1.],\n", " [0., 0., 0., 0., 1., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 1., 0., 0.]])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 5.4 The unitary matrix of the circuit (in paddle.Tensor form)\n", "cir.U\n", "# Change to np.ndarray form\n", "cir.U.numpy()\n", "# Only keep the real part:\n", "cir.U.real()\n", "cir.U.numpy().real" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--*--\n", " | \n", "--x--\n", " \n", "-----\n", " \n" ] } ], "source": [ "# 5.5 Print the circuit\n", "print(cir)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 5.6 Measure outcome\n", "res = cir.measure(shots=0, plot=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Angles in Quantum Gate\n", " Note: \n", "- For qubits unitary gate, they can always be characterized by a rotation axis and a rotation angle. \n", "- The rotation axis in Paddle Quantum is always chosen to be $x,y,z$-axis.\n", "- The rotation angle will be the variable in QNN tasks, and **they should be given in paddle.Tensor form**." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# 6.1 A Single Angle\n", "\n", "phi, theta, omega = 2 * np.pi * np.random.uniform(size=3) # Generate a random angle\n", "# change to paddle.Tensor\n", "phi = paddle.to_tensor(phi, dtype='float64')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# 6.2 Angles in Arrays\n", "# 1D arrays\n", "\n", "theta = np.array([np.pi, 2 ,3, 5]) # 4 angles are different\n", "theta = np.full([4], np.pi) # 4 angles all equal to pi\n", "# change to be paddle.Tensor\n", "theta = paddle.to_tensor(theta)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "# Multidimensional Arrays\n", "\n", "theta = np.random.randn(DEPTH, N, 3) # A 3D np.ndarray" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For a frequently used quantum circuit: cir.complex_entangled_layer(theta, DEPTH), see \n", "[here](https://qml.baidu.com/quick-start/quantum-neural-network.html), the shape of theta should be(DEPTH, N, OTHER=3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7. Add Quantum Gates to the Circuit" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# 7.1 Single qubit gates \n", "# Note: angles should be in paddle.Tensor form.\n", "# Subscript is the rotating axis, the first parameter is the rotating angle, the second is which qubit it acts\n", "\n", "cir.rz(theta[0], 0)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# # 7.2 Two-qubit gate\n", "\n", "cir.cnot([0, 1])" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# 7.3 Some frequently used gates\n", "\n", "# Add Hadamard gates to each qubit\n", "cir.superposition_layer()\n", "# Add a Ry(pi/4) rotation to each qubit\n", "cir.weak_superposition_layer()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "General rotation gate in Euler representation, and the corresponding circuit click [here](https://qml.baidu.com/quick-start/quantum-neural-network.html)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 8. VQA basic structure (1) -- Create your own quantum circuit as a function\n", "- step 1: Create an N qubit circuit;\n", "- step 2: Add gates to each layer" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "def circuit(N, DEPTH, theta):\n", " \"\"\"\n", " Input data:\n", " N, qubits number\n", " DEPTH, layers number\n", " theta, [N, DEPTH, 2], 3D matrix in paddle.Tensor form\n", " Return:\n", " cir, the final circuit\n", " \"\"\"\n", " # step 1: Create an N qubit circuit\n", " cir = UAnsatz(N)\n", " # step 2: Add gates to each layer\n", " for dep in range(DEPTH):\n", " for n in range(N):\n", " cir.rx(theta[n][dep][0], n) # add an Rx gate to the n-th qubit\n", " cir.rz(theta[n][dep][1], n) # add an Rz gate to the n-th qubit\n", " for n in range(N - 1):\n", " cir.cnot([n, n + 1]) # add CNOT gate to every neighbor pair\n", "\n", " return cir" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--Rx(0.069)----Rz(0.473)----*----Rx(-0.65)----Rz(-0.77)-----------------*-------\n", " | | \n", "--Rx(-0.77)----Rz(0.623)----x--------*--------Rx(0.428)----Rz(0.074)----x----*--\n", " | | \n", "--Rx(-0.45)----Rz(0.604)-------------x--------Rx(2.385)----Rz(-0.12)---------x--\n", " \n" ] } ], "source": [ "# Here is the printed final circuit for (N=3, DEPTH=2, theta is randomly generated):\n", "theta = paddle.to_tensor(np.random.randn(N, DEPTH, 2))\n", "theta = paddle.to_tensor(theta)\n", "cir = circuit(N, DEPTH, theta)\n", "print(cir)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 9. VQA basic structure (2) -- forward part, calculate the loss function\n", "- QNN optimization can be done with a Python Iterator, here is an example for preparing quantum state;\n", "- In forward part, all variables should be always in paddle.Tensor form." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "class StatePrepNet(paddle.nn.Layer):\n", " # Step 1: Give the initial input: def __init__(…)\n", " # Here you need to give the parameters for creating your quantum circuit and loss\n", " def __init__(self, N, DEPTH, psi, dtype='float64'):\n", " # N, DEPTH: circuit parameter\n", " # psi: target output pure state, np.row_vector form\n", " super(StatePrepNet, self).__init__()\n", " self.N = N\n", " self.DEPTH = DEPTH\n", " # The initial circuit parameter theta is generated randomly\n", " self.theta = self.create_parameter(shape=[self.N, self.DEPTH, 2],\n", " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2 * np.pi), \n", " dtype=dtype, is_bias=False)\n", " # Target output state, used for loss function\n", " self.psi = paddle.to_tensor(psi)\n", " # Step 2: Calculate the loss function: L = - \n", " # note: here we want to minimize the loss function, so we use “-Fidelity”\n", " def forward(self):\n", " # Create the quantum circuit\n", " cir = circuit(self.N, self.DEPTH, self.theta)\n", " # Get the final state\n", " psi_out = cir.run_state_vector()\n", " psi_out = paddle.reshape(psi_out, [2 ** self.N, 1]) # reshape to ket\n", " # Calculate the loss function: L = - \n", " inner = matmul(self.psi, psi_out)\n", " loss = - paddle.real(matmul(inner, dagger(inner)))[0] # change to shape tensor([1])\n", "\n", " return loss, cir" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 10. VQA basic structure (3) -- backward part, optimize over iteration\n", "- Here we still use preparing a 3-qubit pure state $|01\\rangle\\otimes|+\\rangle$ as an example, and the circuit we use is given in section 8.\n", "- Usually we use Adam as the optimizer." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "N = 3 # Qubits number in Quantum circuit\n", "DEPTH = 2 # Depth of the quantum circuit (Layers number)\n", "ITR = 115 # Iteration number \n", "LR = 0.2 # Learning rate " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "# target output state, np.ndarray row vector\n", "psi_target = np.kron(np.kron(np.array([[1,0]]), np.array([[0,1]])), np.array([[1/np.sqrt(2), 1/np.sqrt(2)]])) # <01+|" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# 10.1 Record the iteration\n", "loss_list = []\n", "parameter_list = []" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "# 10.2 Use Iterator defined in section 9\n", "# (N=3, DEPTH=2, ITR=110, LR=0.2)\n", "myLayer = StatePrepNet(N, DEPTH, psi_target)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "# 10.3 Choose the optimizer\n", "# Usually we use Adam.\n", "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters()) " ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter: 0 loss: -0.0176\n", "iter: 10 loss: -0.8356\n", "iter: 20 loss: -0.9503\n", "iter: 30 loss: -0.9837\n", "iter: 40 loss: -0.9971\n", "iter: 50 loss: -0.9974\n", "iter: 60 loss: -0.9995\n", "iter: 70 loss: -0.9999\n", "iter: 80 loss: -0.9999\n", "iter: 90 loss: -1.0000\n", "iter: 100 loss: -1.0000\n", "iter: 110 loss: -1.0000\n" ] } ], "source": [ "# 10.4 Optimize during iteration\n", "for itr in range(ITR):\n", " # Use forward part to calculate the loss function\n", " loss = myLayer()[0]\n", " # Backward optimize via Gradient descent algorithm\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # Record the learning curve\n", " loss_list.append(loss.numpy()[0])\n", " parameter_list.append(myLayer.parameters()[0].numpy())\n", " if itr % 10 == 0:\n", " print('iter:', itr, ' loss: %.4f' % loss.numpy())" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The minimum of the loss function: -0.9999873168488457\n", "Parameters after optimizationL theta:\n", " [[[-0.00816927 7.41571003]\n", " [ 6.28197865 0.29031951]]\n", "\n", " [[ 3.14801248 6.1562368 ]\n", " [ 6.2890315 4.08082862]]\n", "\n", " [[ 4.57489065 1.58064113]\n", " [ 4.78145659 3.28051687]]]\n", "--Rx(-0.00)----Rz(7.416)----*----Rx(6.282)----Rz(0.290)-----------------*-------\n", " | | \n", "--Rx(3.148)----Rz(6.156)----x--------*--------Rx(6.289)----Rz(4.081)----x----*--\n", " | | \n", "--Rx(4.575)----Rz(1.581)-------------x--------Rx(4.781)----Rz(3.281)---------x--\n", " \n", "state_final:\n", " [-0.0001236 +1.65203739e-04j -0.00051346-3.22614883e-04j\n", " 0.09637039-7.00598643e-01j 0.09558872-7.00513830e-01j\n", " 0.00038931+1.78566178e-04j 0.0003892 +1.76713800e-04j\n", " 0.00209719+1.98540264e-03j 0.0025603 +1.33735551e-03j]\n" ] } ], "source": [ "# 10.5 Print the output\n", "\n", "print('The minimum of the loss function: ', loss_list[-1])\n", "# The parameters after optimization\n", "theta_opt = parameter_list[-1] # Get self.theta\n", "print(\"Parameters after optimizationL theta:\\n\", theta_opt)\n", "# Draw the circuit picture and the output state\n", "# Get theta\n", "theta_final = parameter_list[-1]\n", "theta_final = paddle.to_tensor(theta_final)\n", "# Print the circuit\n", "cir_final = circuit(N, DEPTH, theta_final)\n", "print(cir_final)\n", "# Print the final state\n", "#state_final = cir_final.run_density_matrix()\n", "state_final = cir_final.run_state_vector()\n", "print(\"state_final:\\n\", state_final.numpy())" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Print the loss function during iteration\n", "plt.figure(1)\n", "ITR_list = []\n", "for i in range(ITR):\n", " ITR_list.append(i)\n", "func = plt.plot(ITR_list, loss_list, alpha=0.7, marker='', linestyle='-', color='r')\n", "plt.xlabel('iterations')\n", "plt.ylabel('loss')\n", "plt.legend(labels=[\"loss function during iteration\"], loc='best')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**As the \"-Fidelity\" becomes \"-1\", this circuit learns to prepare the target state \"$|01\\rangle\\otimes|+\\rangle$\".**" ] } ], "metadata": { "interpreter": { "hash": "b79f688f118b7eec4a7bc67db8fbcf9e8f165bc4247c9c8f9f9067a5de2aa71e" }, "kernelspec": { "display_name": "Python 3", "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.7.10" } }, "nbformat": 4, "nbformat_minor": 2 }