From e56ed10d6abaa56b32069bd976422c15d0b41fcd Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Thu, 28 Mar 2024 14:46:22 +0100 Subject: [PATCH 01/15] refactor: differentiation and expectation modules --- .../psr.py => operations/differentiation.py} | 54 +---------- src/qiboml/operations/expectation.py | 91 +++++++++++++++++++ 2 files changed, 92 insertions(+), 53 deletions(-) rename src/qiboml/{differentiation/psr.py => operations/differentiation.py} (79%) create mode 100644 src/qiboml/operations/expectation.py diff --git a/src/qiboml/differentiation/psr.py b/src/qiboml/operations/differentiation.py similarity index 79% rename from src/qiboml/differentiation/psr.py rename to src/qiboml/operations/differentiation.py index 9559551..fcc001a 100644 --- a/src/qiboml/differentiation/psr.py +++ b/src/qiboml/operations/differentiation.py @@ -1,15 +1,12 @@ -from typing import List, Optional, Union - import numpy as np -import qibo from qibo.backends import construct_backend from qibo.config import raise_error from qibo.hamiltonians.abstract import AbstractHamiltonian def parameter_shift( - circuit, hamiltonian, + circuit, parameter_index, initial_state=None, scale_factor=1, @@ -161,52 +158,3 @@ def circuit(nqubits = 1): result = float(generator_eigenval * (forward - backward) * scale_factor) return result - - -def expectation_on_backend( - observable: qibo.hamiltonians.Hamiltonian, - circuit: qibo.Circuit, - initial_state: Optional[Union[List, qibo.Circuit]] = None, - nshots: int = 1000, - backend: str = "qibojit", -): - - params = circuit.get_parameters() - nparams = len(params) - - # read the frontend user choice - frontend = observable.backend - # construct differentiation backend - exec_backend = construct_backend(backend) - - if "tensorflow" in frontend.name: - import tensorflow as tf - - @tf.custom_gradient - def _expectation_with_tf(params): - params = tf.Variable(params) - - def grad(upstream): - gradients = [] - for p in range(nparams): - gradients.append( - upstream - * parameter_shift( - circuit=circuit, - hamiltonian=observable, - parameter_index=p, - nshots=nshots, - backend=backend, - ) - ) - return gradients - - expval = exec_backend.execute_circuit( - circuit=circuit, initial_state=initial_state, nshots=nshots - ).expectation_from_samples(observable) - return expval, grad - - return _expectation_with_tf(params) - - else: - raise_error(NotImplementedError, "Only tensorflow supported at this time.") diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py new file mode 100644 index 0000000..c96ddab --- /dev/null +++ b/src/qiboml/operations/expectation.py @@ -0,0 +1,91 @@ +"""Compute expectation values of target observables with the freedom of setting any qibo's backend.""" + +from typing import List, Optional, Union + +import qibo +from qibo.backends import construct_backend +from qibo.config import raise_error + +from qiboml.operations.differentiation import parameter_shift + + +def expectation_on_backend( + observable: qibo.hamiltonians.Hamiltonian, + circuit: qibo.Circuit, + initial_state: Optional[Union[List, qibo.Circuit]] = None, + nshots: int = 1000, + backend: str = "qibojit", + differentiation_rule: Optional[callable] = parameter_shift, +): + """ + Compute the expectation value of ``observable`` over the state obtained by + executing ``circuit`` starting from ``initial_state``. The final state is + reconstructed from ``nshots`` execution of ``circuit`` on the selected ``backend``. + In addition, a differentiation rule can be set, which is going to be integrated + within the used high-level framework. For example, if TensorFlow is used + in the user code and one parameter shift rule is selected as differentiation + rule, the expectation value is computed informing the TensorFlow graph to + use as gradient the output of the parameter shift rule executed on the selected + backend. + + Args: + observable (qibo.Hamiltonian): the observable whose expectation value has + to be computed. + circuit (qibo.Circuit): quantum circuit returning the final state over which + the expectation value of ``observable`` is computed. + initial_state (Optional[Union[List, qibo.Circuit]]): initial state on which + the quantum circuit is applied. + nshots (int): number of times the quantum circuit is executed. Increasing + the number of shots will reduce the variance of the estimated expectation + value while increasing the computational cost of the operation. + backend (str): backend on which the circuit is executed. This same backend + is used if the chosen differentiation rule makes use of expectation + values. + differentiation_rule (Optional[callable]): the chosen differentiation + rule. It can be selected among the methods implemented in + ``qiboml.differentiation``. + """ + + params = circuit.get_parameters() + nparams = len(params) + + # read the frontend user choice + frontend = observable.backend + # construct differentiation backend + exec_backend = construct_backend(backend) + + if "tensorflow" in frontend.name: + import tensorflow as tf + + @tf.custom_gradient + def _expectation_with_tf(params): + params = tf.Variable(params) + + def grad(upstream): + gradients = [] + for p in range(nparams): + gradients.append( + upstream + * differentiation_rule( + circuit=circuit, + hamiltonian=observable, + parameter_index=p, + initial_state=initial_state, + nshots=nshots, + backend=backend, + ) + ) + return gradients + + expval = exec_backend.execute_circuit( + circuit=circuit, initial_state=initial_state, nshots=nshots + ).expectation_from_samples(observable) + return expval, grad + + return _expectation_with_tf(params) + + else: + raise_error( + NotImplementedError, + "Only tensorflow automatic differentiation is supported at this moment.", + ) From 4deff3af33c0655edecf018e6323dbe28bcbc21f Mon Sep 17 00:00:00 2001 From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com> Date: Tue, 16 Apr 2024 12:41:06 +0200 Subject: [PATCH 02/15] Apply suggestions from code review Co-authored-by: Alessandro Candido --- src/qiboml/operations/expectation.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index c96ddab..5c3a86b 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -84,8 +84,7 @@ def grad(upstream): return _expectation_with_tf(params) - else: - raise_error( - NotImplementedError, - "Only tensorflow automatic differentiation is supported at this moment.", - ) + raise_error( + NotImplementedError, + "Only tensorflow automatic differentiation is supported at this moment.", + ) From 20fd4a8d85ff7948b67de757ec7f13b19fc0d4f9 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Wed, 17 Apr 2024 11:09:53 +0200 Subject: [PATCH 03/15] moving ansatze.py to models --- src/qiboml/{ => models}/ansatze.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/qiboml/{ => models}/ansatze.py (100%) diff --git a/src/qiboml/ansatze.py b/src/qiboml/models/ansatze.py similarity index 100% rename from src/qiboml/ansatze.py rename to src/qiboml/models/ansatze.py From 86022864959b6779d81d9a1353528919e06c2001 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Wed, 17 Apr 2024 11:10:39 +0200 Subject: [PATCH 04/15] rename exp function as expectation --- src/qiboml/operations/expectation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index c96ddab..f178919 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -9,7 +9,7 @@ from qiboml.operations.differentiation import parameter_shift -def expectation_on_backend( +def expectation( observable: qibo.hamiltonians.Hamiltonian, circuit: qibo.Circuit, initial_state: Optional[Union[List, qibo.Circuit]] = None, @@ -54,7 +54,7 @@ def expectation_on_backend( # construct differentiation backend exec_backend = construct_backend(backend) - if "tensorflow" in frontend.name: + if isinstance(frontend.name, "tensorflow"): import tensorflow as tf @tf.custom_gradient From b95188d33ffd1a55348b4996d32e5aa70da10bae Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 22 Apr 2024 18:45:19 +0200 Subject: [PATCH 05/15] small modification to expectation --- src/qiboml/operations/expectation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index bbf87ff..6983857 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -3,7 +3,7 @@ from typing import List, Optional, Union import qibo -from qibo.backends import construct_backend +from qibo.backends import TensorflowBackend, construct_backend from qibo.config import raise_error from qiboml.operations.differentiation import parameter_shift @@ -54,7 +54,7 @@ def expectation( # construct differentiation backend exec_backend = construct_backend(backend) - if isinstance(frontend.name, "tensorflow"): + if isinstance(frontend, TensorflowBackend): import tensorflow as tf @tf.custom_gradient From 6ffef6a3206973fcc6302306a07cbec9f51d63f6 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 22 Apr 2024 18:46:07 +0200 Subject: [PATCH 06/15] tutorials: add custom diff tutorial --- tutorials/custom_differentiation.ipynb | 475 +++++++++++++++++++++++++ 1 file changed, 475 insertions(+) create mode 100644 tutorials/custom_differentiation.ipynb diff --git a/tutorials/custom_differentiation.ipynb b/tutorials/custom_differentiation.ipynb new file mode 100644 index 0000000..addcdeb --- /dev/null +++ b/tutorials/custom_differentiation.ipynb @@ -0,0 +1,475 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "594e8add-362c-40a7-bb46-2d468529d9e9", + "metadata": {}, + "source": [ + "## Custom automatic differentiation\n", + "\n", + "In `Qiboml` we inherit the `backend` mechanism introduced in `Qibo`, extending it to the possibility of executing our quantum circuits on a specific engine indipendently of the choice of the high-level interface. \n", + "\n", + "This means you can decide to work with TensorFlow, or Pytorch, or others, depending on your personal preference, while keeping the possibility to freely set any `Qibo` backend for the circuit's execution.\n", + "\n", + "Moreover, we allow free choice of the differentiation rule to be used, which can be selected among the available differentiation rules implemented in `Qiboml`.\n", + "\n", + "A schematic representation of the pipeline follows, where we use as an example the custom differentiation rule of TensorFlow.\n", + "
\"drawing\"
" + ] + }, + { + "cell_type": "markdown", + "id": "e183c5e9-fac2-4fb0-add6-dad9deffa00e", + "metadata": {}, + "source": [ + "In practice, one defines the problem setup by setting the `Qibo` backend as usual. Let's set `tensorflow`." + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "id": "1cbe98d3-e4c9-4f89-9a27-3918f8877e51", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 235, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import time\n", + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "id": "bbbf2339-efe7-4170-9408-a7b66dff35ae", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.7|INFO|2024-04-22 18:17:14]: Using tensorflow backend on /device:CPU:0\n" + ] + } + ], + "source": [ + "set_backend(\"tensorflow\")" + ] + }, + { + "cell_type": "markdown", + "id": "d904f949-3546-4641-b1d4-c16c75cc8d54", + "metadata": {}, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 282, + "id": "fd9264ff-150c-4be7-89ba-5b5fb37afa3b", + "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" + ] + } + ], + "source": [ + "# circuit\n", + "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", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "id": "6b4afa80-bf2d-45e9-ba46-c7996a463fba", + "metadata": {}, + "outputs": [], + "source": [ + "# set random parameters\n", + "nparams = len(c.get_parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": 284, + "id": "b73dad19-cadc-45d5-8d58-85ee5f4d4247", + "metadata": {}, + "outputs": [], + "source": [ + "# an observable\n", + "obs = hamiltonians.Z(nqubits=nqubits)" + ] + }, + { + "cell_type": "code", + "execution_count": 285, + "id": "6ea9d1a0-e908-4940-9759-fa4c92053ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor(1.5517656244439153, shape=(), dtype=float64)\n" + ] + } + ], + "source": [ + "# compute the expectation value\n", + "final_state = c(nshots=1000).state()\n", + "\n", + "print(obs.expectation(final_state))" + ] + }, + { + "cell_type": "code", + "execution_count": 274, + "id": "0c279101-960f-4ce4-b11f-3297c24e5e72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor(1.522, shape=(), dtype=float64)\n" + ] + } + ], + "source": [ + "exp = expectation.expectation(\n", + " observable=obs,\n", + " circuit=c,\n", + " backend=\"numpy\",\n", + " differentiation_rule=differentiation.parameter_shift\n", + ")\n", + "\n", + "print(exp)" + ] + }, + { + "cell_type": "markdown", + "id": "a859b18b-c18d-4297-9a08-df433480f6e2", + "metadata": {}, + "source": [ + "To check if we are actually changing backend, we can compute a certain number of times the expectation value, and plot the time of execution of different backend engines, such that `tensorflow` or `numpy`." + ] + }, + { + "cell_type": "code", + "execution_count": 275, + "id": "bec419f1-0fca-4d7a-beca-e09947951278", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0/500 exec\n", + "100/500 exec\n", + "200/500 exec\n", + "300/500 exec\n", + "400/500 exec\n" + ] + } + ], + "source": [ + "np_times, tf_times = [0.], [0.]\n", + "nexec = 500\n", + "\n", + "for n in range(nexec):\n", + " # some logging messages\n", + " if (n%100==0):\n", + " print(f\"{n}/{nexec} exec\")\n", + " \n", + " # executing on numpy backend\n", + " it = time.time()\n", + " expectation.expectation(\n", + " observable=obs,\n", + " circuit=c,\n", + " backend=\"numpy\",\n", + " differentiation_rule=differentiation.parameter_shift\n", + " )\n", + " ft = time.time()\n", + " np_times.append((ft-it)+np_times[-1])\n", + "\n", + " # executing on tensorflow backend\n", + " it = time.time()\n", + " expectation.expectation(\n", + " observable=obs,\n", + " circuit=c,\n", + " backend=\"tensorflow\",\n", + " differentiation_rule=differentiation.parameter_shift\n", + " )\n", + " ft = time.time()\n", + " tf_times.append((ft-it)+tf_times[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 276, + "id": "72af880a-092d-4531-85d8-e1809359788d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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.legend()\n", + "plt.xlabel(\"# executions\")\n", + "plt.ylabel(\"Time [s]\")\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3e96cb14-5896-4b60-bd90-138906b2c121", + "metadata": {}, + "source": [ + "This behaviour is expected, since TensorFlow is typically slower than the Numpy backend in executing circuits. It is clear, here, that setting the backend engine to `numpy`, even setting the `frontend` as `tensorflow`, is more convenient." + ] + }, + { + "cell_type": "markdown", + "id": "23608465-be0b-4a78-8733-cfad381b1cf7", + "metadata": {}, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 277, + "id": "e1cc3737-f67b-4fd2-b28d-c025b58d815c", + "metadata": {}, + "outputs": [], + "source": [ + "def cost_function(parameters, circuit, hamiltonian, backend):\n", + " \"\"\"\n", + " Compute expectation value of ``hamiltonian`` over the final state we \n", + " get executing ``circuit`` using ``parameters``.\n", + " \"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 278, + "id": "08cd072f-bc6b-477b-814b-574186ae3d5b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 278, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reload(expectation)" + ] + }, + { + "cell_type": "code", + "execution_count": 295, + "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", + "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" + ] + } + ], + "source": [ + "learning_rate = 0.01\n", + "nepochs = 100\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" + ] + }, + { + "cell_type": "markdown", + "id": "5805a0fe-ade3-4d83-a2ef-41a0a61c3fcb", + "metadata": {}, + "source": [ + "Let's now repeat the same optimization but using `tensorflow` as backend." + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "id": "25d7682a-eb38-486a-ac7b-0cfd07db9b27", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost: 1.556 \t |\t Epoch: 0\n", + "Cost: 1.06 \t |\t Epoch: 10\n", + "Cost: 0.602 \t |\t Epoch: 20\n", + "Cost: -0.104 \t |\t Epoch: 30\n", + "Cost: -0.584 \t |\t Epoch: 40\n", + "Cost: -1.106 \t |\t Epoch: 50\n", + "Cost: -1.588 \t |\t Epoch: 60\n", + "Cost: -1.916 \t |\t Epoch: 70\n", + "Cost: -2.142 \t |\t Epoch: 80\n", + "Cost: -2.302 \t |\t Epoch: 90\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" + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "id": "2a905fa8-7b67-444c-b953-5a7ac3703b75", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization time with tf: 70.71000385284424\n", + "Optimization time with np: 13.57430362701416\n" + ] + } + ], + "source": [ + "print(f\"Optimization time with tf: {tensorflow_time}\")\n", + "print(f\"Optimization time with np: {numpy_time}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8a532c786932ec74d3266558c8e79b0e6320e824 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Tue, 23 Apr 2024 18:36:10 +0200 Subject: [PATCH 07/15] feat: extracting expectation_with_tf from expectation --- src/qiboml/operations/expectation.py | 87 ++++++++++++++++---------- tutorials/custom_differentiation.ipynb | 66 ++++++++++--------- 2 files changed, 89 insertions(+), 64 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 6983857..2692e11 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -3,6 +3,7 @@ from typing import List, Optional, Union import qibo +import tensorflow as tf from qibo.backends import TensorflowBackend, construct_backend from qibo.config import raise_error @@ -46,45 +47,65 @@ def expectation( ``qiboml.differentiation``. """ - params = circuit.get_parameters() - nparams = len(params) - # read the frontend user choice frontend = observable.backend - # construct differentiation backend - exec_backend = construct_backend(backend) if isinstance(frontend, TensorflowBackend): - import tensorflow as tf - - @tf.custom_gradient - def _expectation_with_tf(params): - params = tf.Variable(params) - - def grad(upstream): - gradients = [] - for p in range(nparams): - gradients.append( - upstream - * differentiation_rule( - circuit=circuit, - hamiltonian=observable, - parameter_index=p, - initial_state=initial_state, - nshots=nshots, - backend=backend, - ) - ) - return gradients - - expval = exec_backend.execute_circuit( - circuit=circuit, initial_state=initial_state, nshots=nshots - ).expectation_from_samples(observable) - return expval, grad - - return _expectation_with_tf(params) + return expectation_with_tf( + observable=observable, + circuit=circuit, + initial_state=initial_state, + nshots=nshots, + backend=backend, + differentiation_rule=differentiation_rule, + ) raise_error( NotImplementedError, "Only tensorflow automatic differentiation is supported at this moment.", ) + + +def expectation_with_tf( + observable: qibo.hamiltonians.Hamiltonian, + circuit: qibo.Circuit, + initial_state: Optional[Union[List, qibo.Circuit]] = None, + nshots: int = 1000, + backend: str = "qibojit", + differentiation_rule: Optional[callable] = parameter_shift, +): + """ + Compute expectation sample integrating the custom differentiation rule with + TensorFlow's automatic differentiation. + """ + params = circuit.get_parameters() + nparams = len(params) + + exec_backend = construct_backend(backend) + + @tf.custom_gradient + def _expectation_with_tf(params): + params = tf.Variable(params) + + def grad(upstream): + gradients = [] + for p in range(nparams): + gradients.append( + upstream + * differentiation_rule( + circuit=circuit, + hamiltonian=observable, + parameter_index=p, + initial_state=initial_state, + nshots=nshots, + backend=backend, + ) + ) + return gradients + + expval = exec_backend.execute_circuit( + circuit=circuit, initial_state=initial_state, nshots=nshots + ).expectation_from_samples(observable) + return expval, grad + + return _expectation_with_tf(params) diff --git a/tutorials/custom_differentiation.ipynb b/tutorials/custom_differentiation.ipynb index addcdeb..2700372 100644 --- a/tutorials/custom_differentiation.ipynb +++ b/tutorials/custom_differentiation.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 235, + "execution_count": 22, "id": "1cbe98d3-e4c9-4f89-9a27-3918f8877e51", "metadata": {}, "outputs": [ @@ -37,7 +37,7 @@ "" ] }, - "execution_count": 235, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 236, + "execution_count": 23, "id": "bbbf2339-efe7-4170-9408-a7b66dff35ae", "metadata": {}, "outputs": [ @@ -69,7 +69,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-22 18:17:14]: Using tensorflow backend on /device:CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-23 18:29:05]: Using tensorflow backend on /device:CPU:0\n" ] } ], @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 282, + "execution_count": 24, "id": "fd9264ff-150c-4be7-89ba-5b5fb37afa3b", "metadata": {}, "outputs": [ @@ -120,18 +120,22 @@ }, { "cell_type": "code", - "execution_count": 286, + "execution_count": 25, "id": "6b4afa80-bf2d-45e9-ba46-c7996a463fba", "metadata": {}, "outputs": [], "source": [ "# set random parameters\n", - "nparams = len(c.get_parameters())" + "nparams = len(c.get_parameters())\n", + "np.random.seed(42)\n", + "params = np.random.uniform(0, 2*np.pi, nparams)\n", + "\n", + "c.set_parameters(params)" ] }, { "cell_type": "code", - "execution_count": 284, + "execution_count": 26, "id": "b73dad19-cadc-45d5-8d58-85ee5f4d4247", "metadata": {}, "outputs": [], @@ -142,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": 285, + "execution_count": 27, "id": "6ea9d1a0-e908-4940-9759-fa4c92053ffa", "metadata": {}, "outputs": [ @@ -163,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 274, + "execution_count": 28, "id": "0c279101-960f-4ce4-b11f-3297c24e5e72", "metadata": {}, "outputs": [ @@ -196,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 275, + "execution_count": 29, "id": "bec419f1-0fca-4d7a-beca-e09947951278", "metadata": {}, "outputs": [ @@ -246,13 +250,13 @@ }, { "cell_type": "code", - "execution_count": 276, + "execution_count": 30, "id": "72af880a-092d-4531-85d8-e1809359788d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -292,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 277, + "execution_count": 31, "id": "e1cc3737-f67b-4fd2-b28d-c025b58d815c", "metadata": {}, "outputs": [], @@ -306,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 278, + "execution_count": 32, "id": "08cd072f-bc6b-477b-814b-574186ae3d5b", "metadata": {}, "outputs": [ @@ -316,7 +320,7 @@ "" ] }, - "execution_count": 278, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -327,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 295, + "execution_count": 33, "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", "metadata": {}, "outputs": [ @@ -385,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 297, + "execution_count": 34, "id": "25d7682a-eb38-486a-ac7b-0cfd07db9b27", "metadata": {}, "outputs": [ @@ -393,16 +397,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cost: 1.556 \t |\t Epoch: 0\n", - "Cost: 1.06 \t |\t Epoch: 10\n", - "Cost: 0.602 \t |\t Epoch: 20\n", - "Cost: -0.104 \t |\t Epoch: 30\n", - "Cost: -0.584 \t |\t Epoch: 40\n", - "Cost: -1.106 \t |\t Epoch: 50\n", - "Cost: -1.588 \t |\t Epoch: 60\n", - "Cost: -1.916 \t |\t Epoch: 70\n", - "Cost: -2.142 \t |\t Epoch: 80\n", - "Cost: -2.302 \t |\t Epoch: 90\n" + "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" ] } ], @@ -432,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 298, + "execution_count": 35, "id": "2a905fa8-7b67-444c-b953-5a7ac3703b75", "metadata": {}, "outputs": [ @@ -440,8 +444,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimization time with tf: 70.71000385284424\n", - "Optimization time with np: 13.57430362701416\n" + "Optimization time with tf: 67.71683645248413\n", + "Optimization time with np: 13.010458946228027\n" ] } ], From 8ce9c70ca7a91bddfaef812bf1613130a66cd17e Mon Sep 17 00:00:00 2001 From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com> Date: Wed, 24 Apr 2024 15:16:24 +0200 Subject: [PATCH 08/15] Apply suggestions from code review Co-authored-by: Alessandro Candido --- src/qiboml/operations/expectation.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 2692e11..3be694f 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -50,8 +50,7 @@ def expectation( # read the frontend user choice frontend = observable.backend - if isinstance(frontend, TensorflowBackend): - return expectation_with_tf( + kwargs = dict( observable=observable, circuit=circuit, initial_state=initial_state, @@ -59,6 +58,8 @@ def expectation( backend=backend, differentiation_rule=differentiation_rule, ) + if isinstance(frontend, TensorflowBackend): + return expectation_with_tf(**kwargs) raise_error( NotImplementedError, From 65dfcb7777fc06086290b55d0500f1d1241902b6 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Wed, 24 Apr 2024 15:20:14 +0200 Subject: [PATCH 09/15] removing default values from internal function --- src/qiboml/operations/expectation.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 3be694f..2405ad9 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -51,13 +51,13 @@ def expectation( frontend = observable.backend kwargs = dict( - observable=observable, - circuit=circuit, - initial_state=initial_state, - nshots=nshots, - backend=backend, - differentiation_rule=differentiation_rule, - ) + observable=observable, + circuit=circuit, + initial_state=initial_state, + nshots=nshots, + backend=backend, + differentiation_rule=differentiation_rule, + ) if isinstance(frontend, TensorflowBackend): return expectation_with_tf(**kwargs) @@ -68,12 +68,12 @@ def expectation( def expectation_with_tf( - observable: qibo.hamiltonians.Hamiltonian, - circuit: qibo.Circuit, - initial_state: Optional[Union[List, qibo.Circuit]] = None, - nshots: int = 1000, - backend: str = "qibojit", - differentiation_rule: Optional[callable] = parameter_shift, + observable, + circuit, + initial_state, + nshots, + backend, + differentiation_rule, ): """ Compute expectation sample integrating the custom differentiation rule with From 30896480215d58dd215c062440a43e41808707f6 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Wed, 24 Apr 2024 15:21:46 +0200 Subject: [PATCH 10/15] renaming functions according to Ale's suggestions --- src/qiboml/operations/expectation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 2405ad9..f144ee0 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -59,7 +59,7 @@ def expectation( differentiation_rule=differentiation_rule, ) if isinstance(frontend, TensorflowBackend): - return expectation_with_tf(**kwargs) + return _with_tf(**kwargs) raise_error( NotImplementedError, @@ -67,7 +67,7 @@ def expectation( ) -def expectation_with_tf( +def _with_tf( observable, circuit, initial_state, @@ -85,7 +85,7 @@ def expectation_with_tf( exec_backend = construct_backend(backend) @tf.custom_gradient - def _expectation_with_tf(params): + def _expectation(params): params = tf.Variable(params) def grad(upstream): @@ -109,4 +109,4 @@ def grad(upstream): ).expectation_from_samples(observable) return expval, grad - return _expectation_with_tf(params) + return _expectation(params) From 35d6a06cf79dc4f64cad1ee516e4308e1fd76405 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Wed, 24 Apr 2024 16:11:22 +0200 Subject: [PATCH 11/15] extending expectation to exact case --- src/qiboml/operations/expectation.py | 41 ++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 8 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index f144ee0..8dcfcfe 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -7,16 +7,14 @@ from qibo.backends import TensorflowBackend, construct_backend from qibo.config import raise_error -from qiboml.operations.differentiation import parameter_shift - def expectation( observable: qibo.hamiltonians.Hamiltonian, circuit: qibo.Circuit, initial_state: Optional[Union[List, qibo.Circuit]] = None, - nshots: int = 1000, + nshots: int = None, backend: str = "qibojit", - differentiation_rule: Optional[callable] = parameter_shift, + differentiation_rule: Optional[callable] = None, ): """ Compute the expectation value of ``observable`` over the state obtained by @@ -67,6 +65,22 @@ def expectation( ) +def _exact(observable, circuit, initial_state, exec_backend): + """Helper function to compute exact expectation values.""" + return observable.expectation( + exec_backend.execute_circuit( + circuit=circuit, initial_state=initial_state + ).state() + ) + + +def _with_shots(observable, circuit, initial_state, nshots, exec_backend): + """Helper function to compute expectation values from samples.""" + return exec_backend.execute_circuit( + circuit=circuit, initial_state=initial_state, nshots=nshots + ).expectation_from_samples(observable) + + def _with_tf( observable, circuit, @@ -104,9 +118,20 @@ def grad(upstream): ) return gradients - expval = exec_backend.execute_circuit( - circuit=circuit, initial_state=initial_state, nshots=nshots - ).expectation_from_samples(observable) + if nshots is None: + expval = _exact(observable, circuit, initial_state, exec_backend) + else: + expval = _with_shots( + observable, circuit, initial_state, nshots, exec_backend + ) + return expval, grad - return _expectation(params) + if differentiation_rule is not None: + return _expectation(params) + + elif nshots is None: + return _exact(observable, circuit, initial_state, exec_backend) + + else: + return _with_shots(observable, circuit, initial_state, nshots, exec_backend) From faad4cb49f2efab3158c57eac4822ed9f7afc39d Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Fri, 26 Apr 2024 18:05:39 +0200 Subject: [PATCH 12/15] tutorials: improve tutorial on custom differentiation --- tutorials/custom_differentiation.ipynb | 413 ++++++++++++++++--------- 1 file changed, 275 insertions(+), 138 deletions(-) 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": { From 9d6e8dfaa6d1b8071cd47949f3e69ed4b114dd17 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Fri, 26 Apr 2024 18:16:24 +0200 Subject: [PATCH 13/15] fix: disable pylint import-error --- src/qiboml/operations/expectation.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 8dcfcfe..8ae5654 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -3,7 +3,6 @@ from typing import List, Optional, Union import qibo -import tensorflow as tf from qibo.backends import TensorflowBackend, construct_backend from qibo.config import raise_error @@ -93,6 +92,8 @@ def _with_tf( Compute expectation sample integrating the custom differentiation rule with TensorFlow's automatic differentiation. """ + import tensorflow as tf # pylint: disable=import-error + params = circuit.get_parameters() nparams = len(params) From 3112eb794c3221e80cf1449b12d814b9c846ff5d Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Fri, 26 Apr 2024 18:51:14 +0200 Subject: [PATCH 14/15] fix: figure in tutorial --- tutorials/custom_differentiation.ipynb | 133 ++++++++++--------------- tutorials/figures/customdiff.svg | 12 +++ 2 files changed, 67 insertions(+), 78 deletions(-) create mode 100644 tutorials/figures/customdiff.svg diff --git a/tutorials/custom_differentiation.ipynb b/tutorials/custom_differentiation.ipynb index e341e4f..da1b73e 100644 --- a/tutorials/custom_differentiation.ipynb +++ b/tutorials/custom_differentiation.ipynb @@ -14,7 +14,7 @@ "Moreover, we allow free choice of the differentiation rule to be used, which can be selected among the available differentiation rules implemented in `Qiboml`.\n", "\n", "A schematic representation of the pipeline follows, where we use as an example the custom differentiation rule of TensorFlow.\n", - "
\"drawing\"
" + "
\"drawing\"
" ] }, { @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "1cbe98d3-e4c9-4f89-9a27-3918f8877e51", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "bbbf2339-efe7-4170-9408-a7b66dff35ae", "metadata": {}, "outputs": [ @@ -59,7 +59,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-26 17:24:00]: Using tensorflow backend on /device:CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-26 18:36:39]: Using tensorflow backend on /device:CPU:0\n" ] } ], @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 3, "id": "fd9264ff-150c-4be7-89ba-5b5fb37afa3b", "metadata": {}, "outputs": [], @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "id": "37ba84ff-ecb5-46b1-a060-8a4df87d1c1c", "metadata": {}, "outputs": [ @@ -137,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "id": "6b4afa80-bf2d-45e9-ba46-c7996a463fba", "metadata": {}, "outputs": [], @@ -160,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 6, "id": "b73dad19-cadc-45d5-8d58-85ee5f4d4247", "metadata": {}, "outputs": [], @@ -179,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 7, "id": "6ea9d1a0-e908-4940-9759-fa4c92053ffa", "metadata": {}, "outputs": [ @@ -217,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 8, "id": "0c279101-960f-4ce4-b11f-3297c24e5e72", "metadata": {}, "outputs": [ @@ -251,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 9, "id": "bec419f1-0fca-4d7a-beca-e09947951278", "metadata": {}, "outputs": [ @@ -301,13 +301,13 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 10, "id": "72af880a-092d-4531-85d8-e1809359788d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -350,14 +350,12 @@ "\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." + "We make use of the following function, through which we can customize the training." ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 25, "id": "6c4b84d3-aa09-4536-988e-d3ca02a60dcd", "metadata": {}, "outputs": [], @@ -371,7 +369,8 @@ " Returns: \n", " float: total execution time.\n", " \"\"\"\n", - " learning_rate = 0.05\n", + " # a couple of hyper-parameters\n", + " learning_rate = 0.01\n", " random_seed = 42\n", "\n", " # random parameters\n", @@ -410,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 26, "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", "metadata": {}, "outputs": [ @@ -419,16 +418,16 @@ "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" + "Cost: -0.5636 \t |\t Epoch: 10\n", + "Cost: -0.8084 \t |\t Epoch: 20\n", + "Cost: -0.9856 \t |\t Epoch: 30\n", + "Cost: -1.1273 \t |\t Epoch: 40\n", + "Cost: -1.2492 \t |\t Epoch: 50\n", + "Cost: -1.3579 \t |\t Epoch: 60\n", + "Cost: -1.4559 \t |\t Epoch: 70\n", + "Cost: -1.5443 \t |\t Epoch: 80\n", + "Cost: -1.624 \t |\t Epoch: 90\n", + "Execution time with (tf, psr, tf): 168.4510941505432\n" ] } ], @@ -461,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 27, "id": "775d2bb6-2112-4a47-9c4e-e22938be0194", "metadata": {}, "outputs": [ @@ -470,27 +469,20 @@ "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, np): 13.642082214355469\n" + "Cost: -0.5636 \t |\t Epoch: 10\n", + "Cost: -0.8084 \t |\t Epoch: 20\n", + "Cost: -0.9856 \t |\t Epoch: 30\n", + "Cost: -1.1273 \t |\t Epoch: 40\n", + "Cost: -1.2492 \t |\t Epoch: 50\n", + "Cost: -1.3579 \t |\t Epoch: 60\n", + "Cost: -1.4559 \t |\t Epoch: 70\n", + "Cost: -1.5443 \t |\t Epoch: 80\n", + "Cost: -1.624 \t |\t Epoch: 90\n", + "Execution time with (tf, psr, np): 13.583229541778564\n" ] } ], "source": [ - "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_np_time = train_circuit(\n", " circuit=circuit,\n", " hamiltonian=hamiltonian,\n", @@ -512,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 28, "id": "20e27788-e721-4a66-a606-fd7d8f5eda34", "metadata": {}, "outputs": [ @@ -520,28 +512,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "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" + "Cost: -0.1995 \t |\t Epoch: 0\n", + "Cost: -0.5636 \t |\t Epoch: 10\n", + "Cost: -0.8084 \t |\t Epoch: 20\n", + "Cost: -0.9856 \t |\t Epoch: 30\n", + "Cost: -1.1273 \t |\t Epoch: 40\n", + "Cost: -1.2492 \t |\t Epoch: 50\n", + "Cost: -1.3579 \t |\t Epoch: 60\n", + "Cost: -1.4559 \t |\t Epoch: 70\n", + "Cost: -1.5443 \t |\t Epoch: 80\n", + "Cost: -1.624 \t |\t Epoch: 90\n", + "Execution time with (tf, tf, tf): 8.519932508468628\n" ] } ], "source": [ - "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", @@ -555,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 29, "id": "2a905fa8-7b67-444c-b953-5a7ac3703b75", "metadata": {}, "outputs": [ @@ -563,9 +548,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "(tf, psr, tf): 168.0022475719452\n", - "(tf, psr, np): 13.642082214355469\n", - "(tf, tf, tf): 3.7739181518554688\n" + "(tf, psr, tf): 168.4510941505432\n", + "(tf, psr, np): 13.583229541778564\n", + "(tf, tf, tf): 8.519932508468628\n" ] } ], @@ -582,14 +567,6 @@ "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": { diff --git a/tutorials/figures/customdiff.svg b/tutorials/figures/customdiff.svg new file mode 100644 index 0000000..d8af700 --- /dev/null +++ b/tutorials/figures/customdiff.svg @@ -0,0 +1,12 @@ +
Diff. rule
Backend
Numpy
Qibojit
Pytorch
Tensorflow
Qibolab
Hardware
QML
Fast/lightweight
Frontend
Tensorflow
Pytorch
JAX
@tf.custom_gradient
qiboml.expectation
 From c5aa2e8c24163ad6f05e46ecd0350da3a009c898 Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 29 Apr 2024 18:38:35 +0200 Subject: [PATCH 15/15] moving general returns to expectation function --- src/qiboml/operations/expectation.py | 26 +++++++++++++++----------- tutorials/custom_differentiation.ipynb | 26 +++++++++++++------------- 2 files changed, 28 insertions(+), 24 deletions(-) diff --git a/src/qiboml/operations/expectation.py b/src/qiboml/operations/expectation.py index 8ae5654..228e910 100644 --- a/src/qiboml/operations/expectation.py +++ b/src/qiboml/operations/expectation.py @@ -3,9 +3,11 @@ from typing import List, Optional, Union import qibo -from qibo.backends import TensorflowBackend, construct_backend +from qibo.backends import construct_backend from qibo.config import raise_error +from qiboml.backends import TensorflowBackend + def expectation( observable: qibo.hamiltonians.Hamiltonian, @@ -46,6 +48,7 @@ def expectation( # read the frontend user choice frontend = observable.backend + exec_backend = construct_backend(backend) kwargs = dict( observable=observable, @@ -54,9 +57,17 @@ def expectation( nshots=nshots, backend=backend, differentiation_rule=differentiation_rule, + exec_backend=exec_backend, ) - if isinstance(frontend, TensorflowBackend): - return _with_tf(**kwargs) + + if differentiation_rule is not None: + if isinstance(frontend, TensorflowBackend): + return _with_tf(**kwargs) + + elif nshots is None: + return _exact(observable, circuit, initial_state, exec_backend) + else: + return _with_shots(observable, circuit, initial_state, nshots, exec_backend) raise_error( NotImplementedError, @@ -128,11 +139,4 @@ def grad(upstream): return expval, grad - if differentiation_rule is not None: - return _expectation(params) - - elif nshots is None: - return _exact(observable, circuit, initial_state, exec_backend) - - else: - return _with_shots(observable, circuit, initial_state, nshots, exec_backend) + return _expectation(params) diff --git a/tutorials/custom_differentiation.ipynb b/tutorials/custom_differentiation.ipynb index da1b73e..68152a5 100644 --- a/tutorials/custom_differentiation.ipynb +++ b/tutorials/custom_differentiation.ipynb @@ -59,7 +59,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.7|INFO|2024-04-26 18:36:39]: Using tensorflow backend on /device:CPU:0\n" + "[Qibo 0.2.7|INFO|2024-04-29 18:33:34]: Using tensorflow backend on /device:CPU:0\n" ] } ], @@ -307,7 +307,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,7 +355,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "id": "6c4b84d3-aa09-4536-988e-d3ca02a60dcd", "metadata": {}, "outputs": [], @@ -409,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "id": "26bd1eeb-4479-45c6-859b-21b9dca97c2c", "metadata": {}, "outputs": [ @@ -427,7 +427,7 @@ "Cost: -1.4559 \t |\t Epoch: 70\n", "Cost: -1.5443 \t |\t Epoch: 80\n", "Cost: -1.624 \t |\t Epoch: 90\n", - "Execution time with (tf, psr, tf): 168.4510941505432\n" + "Execution time with (tf, psr, tf): 170.2510015964508\n" ] } ], @@ -460,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "id": "775d2bb6-2112-4a47-9c4e-e22938be0194", "metadata": {}, "outputs": [ @@ -478,7 +478,7 @@ "Cost: -1.4559 \t |\t Epoch: 70\n", "Cost: -1.5443 \t |\t Epoch: 80\n", "Cost: -1.624 \t |\t Epoch: 90\n", - "Execution time with (tf, psr, np): 13.583229541778564\n" + "Execution time with (tf, psr, np): 13.80636191368103\n" ] } ], @@ -504,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 14, "id": "20e27788-e721-4a66-a606-fd7d8f5eda34", "metadata": {}, "outputs": [ @@ -522,7 +522,7 @@ "Cost: -1.4559 \t |\t Epoch: 70\n", "Cost: -1.5443 \t |\t Epoch: 80\n", "Cost: -1.624 \t |\t Epoch: 90\n", - "Execution time with (tf, tf, tf): 8.519932508468628\n" + "Execution time with (tf, tf, tf): 8.758509635925293\n" ] } ], @@ -540,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 15, "id": "2a905fa8-7b67-444c-b953-5a7ac3703b75", "metadata": {}, "outputs": [ @@ -548,9 +548,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "(tf, psr, tf): 168.4510941505432\n", - "(tf, psr, np): 13.583229541778564\n", - "(tf, tf, tf): 8.519932508468628\n" + "(tf, psr, tf): 170.2510015964508\n", + "(tf, psr, np): 13.80636191368103\n", + "(tf, tf, tf): 8.758509635925293\n" ] } ],