diff --git a/tutorials/custom_differentiation.ipynb b/tutorials/custom_differentiation.ipynb index 2700372..e341e4f 100644 --- a/tutorials/custom_differentiation.ipynb +++ b/tutorials/custom_differentiation.ipynb @@ -27,25 +27,18 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "id": "1cbe98d3-e4c9-4f89-9a27-3918f8877e51", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ + "import os\n", "import time\n", "from copy import deepcopy\n", "\n", + "# disabling hardware accelerators warnings\n", + "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n", + "\n", "import numpy as np\n", "import tensorflow as tf\n", "import matplotlib.pyplot as plt\n", @@ -53,15 +46,12 @@ "from qibo import set_backend\n", "from qibo import Circuit, gates, hamiltonians\n", "\n", - "from qiboml.operations import differentiation, expectation\n", - "\n", - "from importlib import reload\n", - "reload(expectation)" + "from qiboml.operations import differentiation, expectation" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 4, "id": "bbbf2339-efe7-4170-9408-a7b66dff35ae", "metadata": {}, "outputs": [ @@ -69,7 +59,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-23 18:29:05]: Using tensorflow backend on /device:CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-26 17:24:00]: Using tensorflow backend on /device:CPU:0\n" ] } ], @@ -84,22 +74,47 @@ "source": [ "Now let's setup a simple problem. We build a quantum circuit $U$ composed of some rotations and we compute the gradients of\n", "$$ \\langle 0 | U^{\\dagger} O U | 0 \\rangle, $$\n", - "where $O$ is an observable." + "where $O$ is an observable.\n", + "\n", + "Let's start with the circuit:" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 34, "id": "fd9264ff-150c-4be7-89ba-5b5fb37afa3b", "metadata": {}, + "outputs": [], + "source": [ + "def build_parametric_circuit(nqubits, nlayers):\n", + " \"\"\"Build a Parametric Quantum Circuit with Qibo.\"\"\"\n", + " \n", + " c = Circuit(nqubits)\n", + " for _ in range(nlayers):\n", + " for q in range(nqubits):\n", + " c.add(gates.RY(q=q, theta=0))\n", + " c.add(gates.RZ(q=q, theta=0))\n", + " for q in range(0, nqubits-1, 1):\n", + " c.add(gates.CNOT(q0=q, q1=q+1))\n", + " c.add(gates.CNOT(q0=nqubits-1, q1=0))\n", + " c.add(gates.M(*range(nqubits)))\n", + "\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "37ba84ff-ecb5-46b1-a060-8a4df87d1c1c", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "q0: ─RY─RZ─RY─RZ─RY─RZ─M─\n", - "q1: ─RY─RZ─RY─RZ─RY─RZ─M─\n", - "q2: ─RY─RZ─RY─RZ─RY─RZ─M─\n" + "q0: ─RY─RZ─o───X─RY─RZ─o───X─RY─RZ─o───X─M─\n", + "q1: ─RY─RZ─X─o─|─RY─RZ─X─o─|─RY─RZ─X─o─|─M─\n", + "q2: ─RY─RZ───X─o─RY─RZ───X─o─RY─RZ───X─o─M─\n" ] } ], @@ -108,19 +123,21 @@ "nqubits = 3\n", "nlayers = 3\n", "\n", - "c = Circuit(nqubits)\n", - "for _ in range(nlayers):\n", - " for q in range(nqubits):\n", - " c.add(gates.RY(q=q, theta=0))\n", - " c.add(gates.RZ(q=q, theta=0))\n", - "c.add(gates.M(*range(nqubits)))\n", - "\n", + "c = build_parametric_circuit(nqubits, nlayers)\n", "print(c.draw())" ] }, + { + "cell_type": "markdown", + "id": "398f2f1f-3c91-4437-9a23-8801753c0785", + "metadata": {}, + "source": [ + "We can fill the circuit with a set of random parameters" + ] + }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 36, "id": "6b4afa80-bf2d-45e9-ba46-c7996a463fba", "metadata": {}, "outputs": [], @@ -133,9 +150,17 @@ "c.set_parameters(params)" ] }, + { + "cell_type": "markdown", + "id": "26162d5b-45ca-45aa-af62-3367ef0d57a7", + "metadata": {}, + "source": [ + "We can now define a simple hamiltonian, which will be our target observable." + ] + }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 37, "id": "b73dad19-cadc-45d5-8d58-85ee5f4d4247", "metadata": {}, "outputs": [], @@ -144,9 +169,17 @@ "obs = hamiltonians.Z(nqubits=nqubits)" ] }, + { + "cell_type": "markdown", + "id": "2142eec0-4010-4140-b393-cccf8d32d1fa", + "metadata": {}, + "source": [ + "Once executed the circuit, we can use the final state to compute the expectation value of the target observable using the appropriate`Qibo` function. " + ] + }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 38, "id": "6ea9d1a0-e908-4940-9759-fa4c92053ffa", "metadata": {}, "outputs": [ @@ -154,7 +187,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "tf.Tensor(1.5517656244439153, shape=(), dtype=float64)\n" + "tf.Tensor(0.34862167327428123, shape=(), dtype=float64)\n" ] } ], @@ -165,9 +198,26 @@ "print(obs.expectation(final_state))" ] }, + { + "cell_type": "markdown", + "id": "793479b8-ee33-4ec4-9b31-5b539234e904", + "metadata": {}, + "source": [ + "On the other hand, we developed a customized version of the `expectation` function in `qiboml`, which allows the user to keep the name convention, while integrating the possibility of customize the automatic differentiation provided by the chosen machine learning framework. It can be called from the `qiboml.expectation` module.\n", + "\n", + "This function accepts some more argument than the `qibo`'s one. In particular:\n", + "\n", + "- `observable`: the target observable, whose expectation value we are interested in;\n", + "- `circuit`: the circuit which returns the final state used to compute the expectation value;\n", + "- `inital_state`: the state of the system before applying the circuit;\n", + "- `nshots`: the number of shots to compute the expectation value;\n", + "- `backend`: the `qibo` backend on which we want to execute the circuit. This backend can even be a real quantum computer, when setting the `qibolab` backend;\n", + "- `differentiation_rule`: the actual differentiation rule one wants to apply. " + ] + }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 39, "id": "0c279101-960f-4ce4-b11f-3297c24e5e72", "metadata": {}, "outputs": [ @@ -175,7 +225,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "tf.Tensor(1.522, shape=(), dtype=float64)\n" + "tf.Tensor(0.2, shape=(), dtype=float64)\n" ] } ], @@ -184,7 +234,8 @@ " observable=obs,\n", " circuit=c,\n", " backend=\"numpy\",\n", - " differentiation_rule=differentiation.parameter_shift\n", + " differentiation_rule=differentiation.parameter_shift,\n", + " nshots=100,\n", ")\n", "\n", "print(exp)" @@ -200,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 40, "id": "bec419f1-0fca-4d7a-beca-e09947951278", "metadata": {}, "outputs": [ @@ -234,7 +285,7 @@ " differentiation_rule=differentiation.parameter_shift\n", " )\n", " ft = time.time()\n", - " np_times.append((ft-it)+np_times[-1])\n", + " np_times.append((ft-it))\n", "\n", " # executing on tensorflow backend\n", " it = time.time()\n", @@ -245,18 +296,18 @@ " differentiation_rule=differentiation.parameter_shift\n", " )\n", " ft = time.time()\n", - " tf_times.append((ft-it)+tf_times[-1])" + " tf_times.append((ft-it))" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 41, "id": "72af880a-092d-4531-85d8-e1809359788d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -267,8 +318,8 @@ ], "source": [ "plt.figure(figsize=(6, 6*6/8))\n", - "plt.plot(np_times, color=\"red\", label=\"Numpy backend\")\n", - "plt.plot(tf_times, color=\"royalblue\", label=\"TensorFlow backend\")\n", + "plt.plot(np.add.accumulate(np_times), color=\"red\", label=\"Numpy backend\")\n", + "plt.plot(np.add.accumulate(tf_times), color=\"royalblue\", label=\"TensorFlow backend\")\n", "plt.legend()\n", "plt.xlabel(\"# executions\")\n", "plt.ylabel(\"Time [s]\")\n", @@ -291,152 +342,220 @@ "source": [ "### Optimization example\n", "\n", - "In the following, we optimize the parameters of the parametric circuit to minimize a target cost function, which is the expectation value of a target hamiltonian. We will repeat this twice, using the `parameter_shift_rule` as differentiation method and both `numpy` and `tensorflow` as backends." + "In the following, we optimize the parameters of the parametric circuit to minimize a target cost function, which is the expectation value of a target hamiltonian. We will repeat this three times, using different configuation of the `qiboml` custom differentiation. Let us describe each of these scenarios with the triad `(frontend, differentiation rule, execution backend)`:\n", + "\n", + "1. `(tf, psr, tf)`: we are working with the TensorFlow interface, we use the parameter shift rule as differentiation algorithm and we execute the circuits using the Qibo's `tensorflow` backend;\n", + "2. `(tf, psr, np)`: we are working with the TensorFlow interface, we use the parameter shift rule as differentiation algorithm and we execute the circuits using the Qibo's `numpy` backend;\n", + "3. `(tf, tf, tf)`: we are working with the TensorFlow interface, we use the tensorflow automatic differentiation algorithm and we execute the circuits using the Qibo's `tensorflow` backend.\n", + "\n", + "Note that these are only three of the many possible combinations. One has to pay attention to the problem configuration, e.g. considering the parameter shift algorithm when executing circuits on real hardware (`qibolab` backend), or activating the shot-noise. In fact, the automatic differentiation of tensorflow breaks when shot-noise is activated.\n", + "\n", + "We make use of the following function, through which we can customize the training. \n", + "We also repeat the same exercise changing the number of the qubits, to analyze the scaling of \n", + "the problem with this hyper-parameter." ] }, { "cell_type": "code", - "execution_count": 31, - "id": "e1cc3737-f67b-4fd2-b28d-c025b58d815c", + "execution_count": 61, + "id": "6c4b84d3-aa09-4536-988e-d3ca02a60dcd", "metadata": {}, "outputs": [], "source": [ - "def cost_function(parameters, circuit, hamiltonian, backend):\n", + "def train_circuit(circuit, hamiltonian, nepochs, exec_backend, differentiation_rule=None, nshots=None):\n", " \"\"\"\n", - " Compute expectation value of ``hamiltonian`` over the final state we \n", - " get executing ``circuit`` using ``parameters``.\n", - " \"\"\"" + " Perform a simple gradient descent training of ``circuit`` to minimize the expectation \n", + " value of ``hamiltonian``. Gradients are computed via the chosen ``differentiation_rule``\n", + " and expectation values calculated executing circuit on the selected ``exec_backend``.\n", + "\n", + " Returns: \n", + " float: total execution time.\n", + " \"\"\"\n", + " learning_rate = 0.05\n", + " random_seed = 42\n", + "\n", + " # random parameters\n", + " np.random.seed(random_seed)\n", + " nparams = len(circuit.get_parameters())\n", + " params = tf.Variable(np.random.uniform(0, 2*np.pi, nparams))\n", + "\n", + " it = time.time()\n", + "\n", + " for epoch in range(nepochs):\n", + " with tf.GradientTape() as tape:\n", + " circuit.set_parameters(params)\n", + " cost = expectation.expectation(\n", + " observable=hamiltonian,\n", + " circuit=circuit,\n", + " backend=exec_backend,\n", + " differentiation_rule=differentiation_rule,\n", + " nshots=nshots,\n", + " )\n", + " if (epoch % 10 == 0):\n", + " print(f\"Cost: {round(cost, 4)} \\t |\\t Epoch: {epoch}\")\n", + " gradients = tape.gradient(cost, params, )\n", + " init_params = params.assign_sub(learning_rate * gradients)\n", + " ft = time.time()\n", + " \n", + " return (ft - it) " + ] + }, + { + "cell_type": "markdown", + "id": "63950898-fd94-422b-a9cf-b9222700c331", + "metadata": {}, + "source": [ + "#### Training scenario 1: `(tf, psr, tf)`" ] }, { "cell_type": "code", - "execution_count": 32, - "id": "08cd072f-bc6b-477b-814b-574186ae3d5b", + "execution_count": 57, + "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost: -0.1995 \t |\t Epoch: 0\n", + "Cost: -1.242 \t |\t Epoch: 10\n", + "Cost: -1.6788 \t |\t Epoch: 20\n", + "Cost: -1.9628 \t |\t Epoch: 30\n", + "Cost: -2.1845 \t |\t Epoch: 40\n", + "Cost: -2.3791 \t |\t Epoch: 50\n", + "Cost: -2.5614 \t |\t Epoch: 60\n", + "Cost: -2.73 \t |\t Epoch: 70\n", + "Cost: -2.8574 \t |\t Epoch: 80\n", + "Cost: -2.9297 \t |\t Epoch: 90\n", + "Execution time with (tf, psr, tf): 168.0022475719452\n" + ] } ], "source": [ - "reload(expectation)" + "nqubits = 3\n", + "nlayers = 5\n", + "\n", + "# setup the problem\n", + "circuit = build_parametric_circuit(nqubits, nlayers)\n", + "hamiltonian = hamiltonians.Z(nqubits)\n", + "\n", + "tf_psr_tf_time = train_circuit(\n", + " circuit=circuit,\n", + " hamiltonian=hamiltonian,\n", + " nepochs=100,\n", + " exec_backend=\"tensorflow\",\n", + " differentiation_rule=differentiation.parameter_shift\n", + ")\n", + "\n", + "print(f\"Execution time with (tf, psr, tf): {tf_psr_tf_time}\")" + ] + }, + { + "cell_type": "markdown", + "id": "08aba037-9dac-4b06-beba-0e3177138091", + "metadata": {}, + "source": [ + "#### Training scenario 2: `(tf, psr, np)`" ] }, { "cell_type": "code", - "execution_count": 33, - "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", + "execution_count": 62, + "id": "775d2bb6-2112-4a47-9c4e-e22938be0194", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Cost: 1.522 \t |\t Epoch: 0\n", - "Cost: 1.042 \t |\t Epoch: 10\n", - "Cost: 0.446 \t |\t Epoch: 20\n", - "Cost: -0.106 \t |\t Epoch: 30\n", - "Cost: -0.524 \t |\t Epoch: 40\n", - "Cost: -1.098 \t |\t Epoch: 50\n", - "Cost: -1.442 \t |\t Epoch: 60\n", - "Cost: -1.84 \t |\t Epoch: 70\n", - "Cost: -2.106 \t |\t Epoch: 80\n", - "Cost: -2.386 \t |\t Epoch: 90\n" + "Cost: -0.1995 \t |\t Epoch: 0\n", + "Cost: -1.242 \t |\t Epoch: 10\n", + "Cost: -1.6788 \t |\t Epoch: 20\n", + "Cost: -1.9628 \t |\t Epoch: 30\n", + "Cost: -2.1845 \t |\t Epoch: 40\n", + "Cost: -2.3791 \t |\t Epoch: 50\n", + "Cost: -2.5614 \t |\t Epoch: 60\n", + "Cost: -2.73 \t |\t Epoch: 70\n", + "Cost: -2.8574 \t |\t Epoch: 80\n", + "Cost: -2.9297 \t |\t Epoch: 90\n", + "Execution time with (tf, psr, np): 13.642082214355469\n" ] } ], "source": [ - "learning_rate = 0.01\n", - "nepochs = 100\n", + "nqubits = 3\n", + "nlayers = 5\n", "\n", - "# set random generator seed\n", - "np.random.seed(42)\n", - "params = tf.Variable(np.random.uniform(0, 2*np.pi, nparams))\n", - "\n", - "it = time.time()\n", - "for epoch in range(nepochs):\n", - " with tf.GradientTape() as tape:\n", - " c.set_parameters(params)\n", - " cost = expectation.expectation(\n", - " observable=obs,\n", - " circuit=c,\n", - " backend=\"numpy\",\n", - " differentiation_rule=differentiation.parameter_shift\n", - " )\n", - " if (epoch % 10 == 0):\n", - " print(f\"Cost: {round(cost, 4)} \\t |\\t Epoch: {epoch}\")\n", - " gradients = tape.gradient(cost, params)\n", - " init_params = params.assign_sub(learning_rate * gradients)\n", - "ft = time.time()\n", - "\n", - "numpy_time = ft - it" + "# setup the problem\n", + "circuit = build_parametric_circuit(nqubits, nlayers)\n", + "hamiltonian = hamiltonians.Z(nqubits)\n", + "\n", + "tf_psr_np_time = train_circuit(\n", + " circuit=circuit,\n", + " hamiltonian=hamiltonian,\n", + " nepochs=100,\n", + " exec_backend=\"numpy\",\n", + " differentiation_rule=differentiation.parameter_shift\n", + ")\n", + "\n", + "print(f\"Execution time with (tf, psr, np): {tf_psr_np_time}\")" ] }, { "cell_type": "markdown", - "id": "5805a0fe-ade3-4d83-a2ef-41a0a61c3fcb", + "id": "c24cfb3b-d9e2-4aaf-a590-63712e9d9afb", "metadata": {}, "source": [ - "Let's now repeat the same optimization but using `tensorflow` as backend." + "#### Training scenario 3: `(tf, tf, tf)`" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "25d7682a-eb38-486a-ac7b-0cfd07db9b27", + "execution_count": 63, + "id": "20e27788-e721-4a66-a606-fd7d8f5eda34", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Cost: 1.536 \t |\t Epoch: 0\n", - "Cost: 1.018 \t |\t Epoch: 10\n", - "Cost: 0.564 \t |\t Epoch: 20\n", - "Cost: -0.05 \t |\t Epoch: 30\n", - "Cost: -0.6 \t |\t Epoch: 40\n", - "Cost: -0.956 \t |\t Epoch: 50\n", - "Cost: -1.422 \t |\t Epoch: 60\n", - "Cost: -1.934 \t |\t Epoch: 70\n", - "Cost: -2.19 \t |\t Epoch: 80\n", - "Cost: -2.416 \t |\t Epoch: 90\n" + "Cost: 0.216 \t |\t Epoch: 0\n", + "Cost: -0.2827 \t |\t Epoch: 10\n", + "Cost: -0.5996 \t |\t Epoch: 20\n", + "Cost: -0.7808 \t |\t Epoch: 30\n", + "Cost: -0.8834 \t |\t Epoch: 40\n", + "Cost: -0.938 \t |\t Epoch: 50\n", + "Cost: -0.966 \t |\t Epoch: 60\n", + "Cost: -0.9804 \t |\t Epoch: 70\n", + "Cost: -0.9882 \t |\t Epoch: 80\n", + "Cost: -0.9927 \t |\t Epoch: 90\n", + "Execution time with (tf, tf, tf): 3.7739181518554688\n" ] } ], "source": [ - "# set random generator seed\n", - "np.random.seed(42)\n", - "params = tf.Variable(np.random.uniform(0, 2*np.pi, nparams))\n", - "\n", - "it = time.time()\n", - "for epoch in range(nepochs):\n", - " with tf.GradientTape() as tape:\n", - " c.set_parameters(params)\n", - " cost = expectation.expectation(\n", - " observable=obs,\n", - " circuit=c,\n", - " backend=\"tensorflow\",\n", - " differentiation_rule=differentiation.parameter_shift\n", - " )\n", - " if (epoch % 10 == 0):\n", - " print(f\"Cost: {round(cost, 4)} \\t |\\t Epoch: {epoch}\")\n", - " gradients = tape.gradient(cost, params)\n", - " init_params = params.assign_sub(learning_rate * gradients)\n", - "ft = time.time()\n", - "\n", - "tensorflow_time = ft - it" + "nqubits = 3\n", + "nlayers = 2\n", + "\n", + "# setup the problem\n", + "circuit = build_parametric_circuit(nqubits, nlayers)\n", + "hamiltonian = hamiltonians.Z(nqubits)\n", + "\n", + "tf_tf_tf_time = train_circuit(\n", + " circuit=circuit,\n", + " hamiltonian=hamiltonian,\n", + " nepochs=100,\n", + " exec_backend=\"tensorflow\",\n", + " differentiation_rule=None\n", + ")\n", + "\n", + "print(f\"Execution time with (tf, tf, tf): {tf_tf_tf_time}\")" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 64, "id": "2a905fa8-7b67-444c-b953-5a7ac3703b75", "metadata": {}, "outputs": [ @@ -444,15 +563,33 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimization time with tf: 67.71683645248413\n", - "Optimization time with np: 13.010458946228027\n" + "(tf, psr, tf): 168.0022475719452\n", + "(tf, psr, np): 13.642082214355469\n", + "(tf, tf, tf): 3.7739181518554688\n" ] } ], "source": [ - "print(f\"Optimization time with tf: {tensorflow_time}\")\n", - "print(f\"Optimization time with np: {numpy_time}\")" + "print(f\"(tf, psr, tf): {tf_psr_tf_time}\")\n", + "print(f\"(tf, psr, np): {tf_psr_np_time}\")\n", + "print(f\"(tf, tf, tf): {tf_tf_tf_time}\")" + ] + }, + { + "cell_type": "markdown", + "id": "79c62b66-ac75-4cad-97af-d45851cffe1b", + "metadata": {}, + "source": [ + "It is clear in this setup the last configuration is the fastest. This can be explained considering TensorFlow's automatic differentiation routines, which are well optimized to compute the backpropagation algorithm. But if we activate the shot-noise the discussion changes. In fact, the TensorFlow automatic differentiation is not usable in a shot-noise setup, and one of the other options has to be set. In that case, using the `numpy` (or the `) backend" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27233b0a-6a2e-4609-9a13-96b46eada437", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {