From 3237be40c0292b44873ee5d0d909cde3ccc8c49e Mon Sep 17 00:00:00 2001 From: MatteoRobbiati Date: Mon, 17 Feb 2025 11:32:49 +0100 Subject: [PATCH] refactor: move notebook back to examples --- doc/source/code-examples/introductions.rst | 12 + .../qmatchatea_introduction.ipynb | 1 + .../qmatchatea_introduction.ipynb | 581 ++++++++++++++++++ 3 files changed, 594 insertions(+) create mode 100644 doc/source/code-examples/introductions.rst create mode 120000 doc/source/code-examples/tutorials/qmatchatea_intro/qmatchatea_introduction.ipynb create mode 100644 examples/qmatchatea_intro/qmatchatea_introduction.ipynb diff --git a/doc/source/code-examples/introductions.rst b/doc/source/code-examples/introductions.rst new file mode 100644 index 0000000..0afdad7 --- /dev/null +++ b/doc/source/code-examples/introductions.rst @@ -0,0 +1,12 @@ +.. _introductions: + +Introductory material +===================== + +In this section we present some simple introduction to our backends. + + +.. toctree:: + :maxdepth: 1 + + tutorials/qmatchatea_intro/qmatchatea_intro.ipynb diff --git a/doc/source/code-examples/tutorials/qmatchatea_intro/qmatchatea_introduction.ipynb b/doc/source/code-examples/tutorials/qmatchatea_intro/qmatchatea_introduction.ipynb new file mode 120000 index 0000000..987158a --- /dev/null +++ b/doc/source/code-examples/tutorials/qmatchatea_intro/qmatchatea_introduction.ipynb @@ -0,0 +1 @@ +../../../../../examples/qmatchatea_intro/qmatchatea_introduction.ipynb \ No newline at end of file diff --git a/examples/qmatchatea_intro/qmatchatea_introduction.ipynb b/examples/qmatchatea_intro/qmatchatea_introduction.ipynb new file mode 100644 index 0000000..6a338e2 --- /dev/null +++ b/examples/qmatchatea_intro/qmatchatea_introduction.ipynb @@ -0,0 +1,581 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "656bb283-ac6d-48d2-a029-3c417c9961f8", + "metadata": {}, + "source": [ + "## Introduction to Quantum Matcha Tea backend in QiboTN\n", + "\n", + "#### Some imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6722d94e-e311-48f9-b6df-c6d829bf67fb", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "from scipy import stats\n", + "\n", + "import qibo\n", + "from qibo import Circuit, gates, hamiltonians\n", + "from qibo.backends import construct_backend" + ] + }, + { + "cell_type": "markdown", + "id": "a009a5e0-cfd4-4a49-9f7c-e82f252c6147", + "metadata": {}, + "source": [ + "#### Some hyper parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "64162116-1555-4a68-811c-01593739d622", + "metadata": {}, + "outputs": [], + "source": [ + "# construct qibotn backend\n", + "qmatcha_backend = construct_backend(backend=\"qibotn\", platform=\"qmatchatea\")\n", + "\n", + "# set number of qubits\n", + "nqubits = 4\n", + "\n", + "# set numpy random seed\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "id": "252f5cd1-5932-4de6-8076-4a357d50ebad", + "metadata": {}, + "source": [ + "#### Constructing a parametric quantum circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4a22a172-f50d-411d-afa3-fa61937c7b3a", + "metadata": {}, + "outputs": [], + "source": [ + "def build_circuit(nqubits, nlayers):\n", + " \"\"\"Construct a parametric quantum circuit.\"\"\"\n", + " circ = Circuit(nqubits)\n", + " for _ in range(nlayers):\n", + " for q in range(nqubits):\n", + " circ.add(gates.RY(q=q, theta=0.))\n", + " circ.add(gates.RZ(q=q, theta=0.))\n", + " [circ.add(gates.CNOT(q%nqubits, (q+1)%nqubits) for q in range(nqubits))]\n", + " circ.add(gates.M(*range(nqubits)))\n", + " return circ" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "76f23c57-6d08-496b-9a27-52fb63bbfcb1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ─RY─RZ─o─────X─RY─RZ─o─────X─RY─RZ─o─────X─M─\n", + "1: ─RY─RZ─X─o───|─RY─RZ─X─o───|─RY─RZ─X─o───|─M─\n", + "2: ─RY─RZ───X─o─|─RY─RZ───X─o─|─RY─RZ───X─o─|─M─\n", + "3: ─RY─RZ─────X─o─RY─RZ─────X─o─RY─RZ─────X─o─M─\n" + ] + } + ], + "source": [ + "circuit = build_circuit(nqubits=nqubits, nlayers=3)\n", + "circuit.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "07b2c097-cea2-42ec-8f1d-b4bbb5b71d98", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting random parameters\n", + "circuit.set_parameters(\n", + " parameters=np.random.uniform(-np.pi, np.pi, len(circuit.get_parameters())),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fd0cea52-03f5-4366-a01a-a5a84aa8ebc7", + "metadata": {}, + "source": [ + "#### Setting up the tensor network simulator\n", + "\n", + "Depending on the simulator, various parameters can be set. One can customize the tensor network execution via the `backend.configure_tn_simulation` function, whose face depends on the specific backend provider." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2ee03e94-d794-4a51-9e76-01e8d8a259ba", + "metadata": {}, + "outputs": [], + "source": [ + "# Customization of the tensor network simulation in the case of qmatchatea\n", + "# Here we use only some of the possible arguments\n", + "qmatcha_backend.configure_tn_simulation(\n", + " ansatz=\"MPS\",\n", + " max_bond_dimension=10,\n", + " cut_ratio=1e-6,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "648d85b8-445d-4081-aeed-1691fbae67be", + "metadata": {}, + "source": [ + "#### Executing through the backend\n", + "\n", + "The `backend.execute_circuit` method can be used then. We can simulate results in three ways:\n", + "1. reconstruction of the final state (statevector like, only if `nqubits < 20` due to Quantum Matcha Tea setup) only if `return_array` is set to `True`;\n", + "2. computation of the relevant probabilities of the final state. There are three way of doing so, but we will see it directly into the docstrings;\n", + "3. reconstruction of the relevant state's frequencies (only if `nshots` is not `None`)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "35a244c3-adba-4b8b-b28c-0ab592b0f7cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': None,\n", + " 'measured_probabilities': {'U': {'0000': (0.0, 0.08390937969317301),\n", + " '0001': (0.08390937969317301, 0.08858639088838134),\n", + " '0010': (0.08858639088838131, 0.1832549957082757),\n", + " '0011': (0.1832549957082757, 0.25896776804349736),\n", + " '0100': (0.2589677680434974, 0.33039716334036867),\n", + " '0101': (0.33039716334036867, 0.386620221067355),\n", + " '0110': (0.3866202210673549, 0.4380808691410473),\n", + " '0111': (0.4380808691410473, 0.47837271988834),\n", + " '1000': (0.47837271988834, 0.5916815553716759),\n", + " '1001': (0.5916815553716759, 0.5972581739037379),\n", + " '1010': (0.5972581739037378, 0.6359857590550054),\n", + " '1011': (0.6359857590550054, 0.6894851559808782),\n", + " '1100': (0.6894851559808783, 0.7030911408535467),\n", + " '1101': (0.7030911408535467, 0.8264027395524797),\n", + " '1110': (0.8264027395524797, 0.8981519382820797),\n", + " '1111': (0.8981519382820797, 0.9999999999999998)},\n", + " 'E': [None],\n", + " 'G': [None]},\n", + " 'prob_type': 'U',\n", + " 'statevector': None}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Simple execution (defaults)\n", + "outcome = qmatcha_backend.execute_circuit(circuit=circuit)\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60501c3d-2a44-421f-b434-4a508714b132", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': None,\n", + " 'measured_probabilities': {'U': [None],\n", + " 'E': [None],\n", + " 'G': {'1110': 0.07174919872960005,\n", + " '1111': 0.10184806171792007,\n", + " '0010': 0.09466860481989439,\n", + " '0011': 0.07571277233522165}},\n", + " 'prob_type': 'G',\n", + " 'statevector': array([ 0.08809627-0.27595005j, 0.24859731-0.22695421j,\n", + " 0.18807826+0.18988408j, 0.09444097+0.06846085j,\n", + " 0.00470148+0.30764671j, 0.17371395-0.09247188j,\n", + " -0.18900305+0.12545316j, -0.17359753+0.20399288j,\n", + " -0.0517478 +0.04471215j, -0.0411739 -0.06230031j,\n", + " 0.22377064+0.07842041j, -0.21784975-0.27541439j,\n", + " -0.27208941+0.04098933j, -0.22748127+0.04185292j,\n", + " 0.17105258-0.10503745j, -0.01729753-0.31866731j])}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execution with a specific probability type\n", + "# We use here \"E\", which is cutting some of the components if under a threshold\n", + "# We also retrieve the statevector\n", + "outcome = qmatcha_backend.execute_circuit(\n", + " circuit=circuit,\n", + " prob_type=\"G\",\n", + " prob_threshold=0.3,\n", + " return_array=True,\n", + ")\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "markdown", + "id": "84ec0b48-f6b4-495c-93b8-8e42d1a8b0df", + "metadata": {}, + "source": [ + "---\n", + "\n", + "One can access to the specific contents of the simulation outcome." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c0443efc-21ef-4ed5-9cf4-785d204a1881", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probabilities:\n", + " [0.0717492 0.10184806 0.0946686 0.07571277]\n", + "\n", + "State:\n", + " [ 0.08809627-0.27595005j 0.24859731-0.22695421j 0.18807826+0.18988408j\n", + " 0.09444097+0.06846085j 0.00470148+0.30764671j 0.17371395-0.09247188j\n", + " -0.18900305+0.12545316j -0.17359753+0.20399288j -0.0517478 +0.04471215j\n", + " -0.0411739 -0.06230031j 0.22377064+0.07842041j -0.21784975-0.27541439j\n", + " -0.27208941+0.04098933j -0.22748127+0.04185292j 0.17105258-0.10503745j\n", + " -0.01729753-0.31866731j]\n", + "\n" + ] + } + ], + "source": [ + "print(f\"Probabilities:\\n {outcome.probabilities()}\\n\")\n", + "print(f\"State:\\n {outcome.state()}\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "9f477388-ca45-409a-a0ce-6603ec294e42", + "metadata": {}, + "source": [ + "---\n", + "\n", + "But frequencies cannot be accessed, since no shots have been set." + ] + }, + { + "cell_type": "markdown", + "id": "8e9413c7-602a-44ed-a50c-1c3dd4dd7494", + "metadata": {}, + "source": [ + "---\n", + "\n", + "We can then repeat the execution by setting the number of shots" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "68122cd3-662f-4fd1-bb9c-d33b6f5448dd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': {'0000': 92,\n", + " '0001': 7,\n", + " '0010': 85,\n", + " '0011': 79,\n", + " '0100': 81,\n", + " '0101': 55,\n", + " '0110': 47,\n", + " '0111': 39,\n", + " '1000': 117,\n", + " '1001': 7,\n", + " '1010': 38,\n", + " '1011': 53,\n", + " '1100': 22,\n", + " '1101': 129,\n", + " '1110': 74,\n", + " '1111': 99},\n", + " 'measured_probabilities': {'U': [None],\n", + " 'E': {'0000': 0.08390937969317301,\n", + " '0010': 0.09466860481989439,\n", + " '0011': 0.07571277233522165,\n", + " '0100': 0.07142939529687124,\n", + " '0101': 0.05622305772698632,\n", + " '0110': 0.05146064807369245,\n", + " '1000': 0.11330883548333581,\n", + " '1011': 0.053499396925872765,\n", + " '1101': 0.12331159869893296,\n", + " '1110': 0.07174919872960005,\n", + " '1111': 0.10184806171792007},\n", + " 'G': [None]},\n", + " 'prob_type': 'E',\n", + " 'statevector': array([ 0.08809627-0.27595005j, 0.24859731-0.22695421j,\n", + " 0.18807826+0.18988408j, 0.09444097+0.06846085j,\n", + " 0.00470148+0.30764671j, 0.17371395-0.09247188j,\n", + " -0.18900305+0.12545316j, -0.17359753+0.20399288j,\n", + " -0.0517478 +0.04471215j, -0.0411739 -0.06230031j,\n", + " 0.22377064+0.07842041j, -0.21784975-0.27541439j,\n", + " -0.27208941+0.04098933j, -0.22748127+0.04185292j,\n", + " 0.17105258-0.10503745j, -0.01729753-0.31866731j])}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execution with a specific probability type\n", + "# We use here \"E\", which is cutting some of the components if under a threshold\n", + "outcome = qmatcha_backend.execute_circuit(\n", + " circuit=circuit,\n", + " nshots=1024,\n", + " prob_type=\"E\",\n", + " prob_threshold=0.05,\n", + " return_array=True\n", + ")\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ef0e9591-ccca-4cdd-a81b-2bfb3caaf3d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequencies:\n", + " {'0000': 92, '0001': 7, '0010': 85, '0011': 79, '0100': 81, '0101': 55, '0110': 47, '0111': 39, '1000': 117, '1001': 7, '1010': 38, '1011': 53, '1100': 22, '1101': 129, '1110': 74, '1111': 99}\n", + "\n", + "Probabilities:\n", + " [0.08390938 0.0946686 0.07571277 0.0714294 0.05622306 0.05146065\n", + " 0.11330884 0.0534994 0.1233116 0.0717492 0.10184806]\n", + "\n", + "State:\n", + " [ 0.08809627-0.27595005j 0.24859731-0.22695421j 0.18807826+0.18988408j\n", + " 0.09444097+0.06846085j 0.00470148+0.30764671j 0.17371395-0.09247188j\n", + " -0.18900305+0.12545316j -0.17359753+0.20399288j -0.0517478 +0.04471215j\n", + " -0.0411739 -0.06230031j 0.22377064+0.07842041j -0.21784975-0.27541439j\n", + " -0.27208941+0.04098933j -0.22748127+0.04185292j 0.17105258-0.10503745j\n", + " -0.01729753-0.31866731j]\n", + "\n" + ] + } + ], + "source": [ + "# Frequencies and probabilities\n", + "print(f\"Frequencies:\\n {outcome.frequencies()}\\n\")\n", + "print(f\"Probabilities:\\n {outcome.probabilities()}\\n\")\n", + "print(f\"State:\\n {outcome.state()}\\n\") # Only if return_array = True" + ] + }, + { + "cell_type": "markdown", + "id": "dd84f1f3-7aa5-4ad1-ae09-81e0aff75b5b", + "metadata": {}, + "source": [ + "### Compute expectation values\n", + "\n", + "Another important feature of this backend is the `expectation` function. In fact, we can compute expectation values of given observables thorugh a Qibo-friendly interface.\n", + "\n", + "---\n", + "\n", + "Let's start by importing some symbols, thanks to which we can build our observable." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0b46e315-7786-4247-bd2a-83ea1c5842eb", + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.symbols import Z, X" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "37385485-e8a3-4ab0-ad44-bcc4e9da24ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ─RY─RZ─o─────X─RY─RZ─o─────X─RY─RZ─o─────X─M─\n", + "1: ─RY─RZ─X─o───|─RY─RZ─X─o───|─RY─RZ─X─o───|─M─\n", + "2: ─RY─RZ───X─o─|─RY─RZ───X─o─|─RY─RZ───X─o─|─M─\n", + "3: ─RY─RZ─────X─o─RY─RZ─────X─o─RY─RZ─────X─o─M─\n" + ] + } + ], + "source": [ + "# We are going to compute the expval of an Hamiltonian\n", + "# On the state prepared by the following circuit\n", + "circuit.draw()\n", + "\n", + "circuit.set_parameters(\n", + " np.random.randn(len(circuit.get_parameters()))\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ddecc910-7804-4199-8577-a7db38a16db8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.15|INFO|2025-02-12 14:36:17]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle - 1.5 X_{0} Z_{2} + 0.5 Z_{0} Z_{1} + Z_{3}$" + ], + "text/plain": [ + "-1.5*X0*Z2 + 0.5*Z0*Z1 + Z3" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# We can create a symbolic Hamiltonian\n", + "form = 0.5 * Z(0) * Z(1) +- 1.5 * X(0) * Z(2) + Z(3)\n", + "hamiltonian = hamiltonians.SymbolicHamiltonian(form)\n", + "\n", + "# Let's show it\n", + "hamiltonian.form" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "163b70a3-814a-4a62-a98a-2ffca933a544", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.4355195352502318" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# And compute its expectation value\n", + "qmatcha_backend.expectation(\n", + " circuit=circuit,\n", + " observable=hamiltonian,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2d8c4a9c-eca3-49d0-bdbf-ab054172c4e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.43551953525022985" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Try with Qibo (which is by default using the Qibojit backend)\n", + "hamiltonian = hamiltonians.SymbolicHamiltonian(form)\n", + "hamiltonian.expectation(circuit().state())" + ] + }, + { + "cell_type": "markdown", + "id": "94df291c-9ddc-4b2e-8442-5fca00784bd8", + "metadata": {}, + "source": [ + "They match! 🥳" + ] + } + ], + "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 +}